PCEP-30-02 Data Collections - Tuples, Dictionaries, Lists, and Strings

Data Collections - Tuples, Dictionaries, Lists, and Strings Detailed Explanation

1. Lists

Lists are one of the most versatile and commonly used data structures in Python. They allow you to store multiple items in a single variable.

1.1 Definition

• A list is:
  • Ordered: Items have a specific sequence.
  • Mutable: Items can be changed after the list is created.
  • Heterogeneous: Items can be of different data types.
• Syntax: Lists are defined using square brackets [].

Example:

#A list of fruits
fruits = ["apple", "banana", "cherry"]

#A mixed-type list
mixed_list = [42, "hello", 3.14]

1.2 Basic Operations

1. Creating a List:

   fruits = ["apple", "banana", "cherry"]
   

2. Accessing Items:

   • Access by index (starts at 0 for the first item).
   • Negative indices start from the end (-1 for the last item).

   print(fruits[0])  # Output: apple
   print(fruits[-1])  # Output: cherry
   

3. Modifying Items:

   • Lists are mutable, so you can modify items using their index.

   fruits[1] = "orange"
   print(fruits)  # Output: ['apple', 'orange', 'cherry']
   

1.3 List Methods

1. Appending Items:

   • Add an item to the end of the list.

   fruits.append("grape")
   print(fruits)  # Output: ['apple', 'orange', 'cherry', 'grape']
   

2. Inserting Items:

   • Insert an item at a specific index.

   fruits.insert(1, "kiwi")
   print(fruits)  # Output: ['apple', 'kiwi', 'orange', 'cherry', 'grape']
   

3. Removing Items:

   • Remove by value:

     fruits.remove("orange")
     print(fruits)  # Output: ['apple', 'kiwi', 'cherry', 'grape']
     

   • Remove by index:

     fruits.pop(0)  # Removes 'apple'
     print(fruits)  # Output: ['kiwi', 'cherry', 'grape']
     

4. Sorting Items:

   • Alphabetically or numerically.

   fruits.sort()
   print(fruits)  # Output: ['cherry', 'grape', 'kiwi']
   

5. Reversing Items:

   • Reverse the order of items.

   fruits.reverse()
   print(fruits)  # Output: ['kiwi', 'grape', 'cherry']
   

1.4 Slicing

• Extract a sublist using indices.
• Syntax: list[start:end] (start inclusive, end exclusive).

sublist = fruits[1:3]
print(sublist)  # Output: ['grape', 'cherry']

1.5 Iterating

• Use a for loop to iterate through items.

for fruit in fruits:
    print(fruit)

Output:

kiwi
grape
cherry

2. Tuples

Tuples are similar to lists but immutable, meaning their contents cannot be changed after creation.

2.1 Definition

• A tuple is:
  • Ordered: Items have a specific sequence.
  • Immutable: Cannot modify items once created.
  • Heterogeneous: Can contain different data types.
• Syntax: Tuples are defined using parentheses ().

Example:

coordinates = (10, 20)

2.2 Basic Operations

1. Creating a Tuple:

   numbers = (1, 2, 3)
   

2. Accessing Items:

   • Similar to lists, use indices.

   print(coordinates[0])  # Output: 10
   

2.3 Immutability

• Tuples cannot be modified.
• Attempting to do so raises an error.

coordinates[0] = 15  # TypeError: 'tuple' object does not support item assignment

2.4 Common Use Cases

1. Returning Multiple Values:

   • Functions can return multiple values as a tuple.

   def get_coordinates():
      return (10, 20)
   
   x, y = get_coordinates()
   print(x, y)  # Output: 10 20
   

2. Using Tuples as Keys:

   • Tuples are hashable and can be used as dictionary keys (unlike lists).

3. Dictionaries

Dictionaries are collections of key-value pairs, where each key is unique.

3.1 Definition

• A dictionary:
  • Unordered: Items do not maintain a fixed order (Python 3.7+ maintains insertion order).
  • Mutable: Can add, modify, or delete key-value pairs.
  • Keys must be immutable (e.g., strings, numbers, or tuples).
• Syntax: Defined using curly braces {}.

Example:

person = {"name": "Alice", "age": 25}

3.2 Basic Operations

1. Creating a Dictionary:

   person = {"name": "Alice", "age": 25}
   

2. Accessing Values:

   • Use the key to retrieve the corresponding value.

   print(person["name"])  # Output: Alice
   

3. Adding or Updating Items:

   • Add a new key-value pair or update an existing one.

   person["city"] = "New York"
   print(person)  # Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}
   

4. Deleting Items:

   • Remove a key-value pair using del.

   del person["age"]
   print(person)  # Output: {'name': 'Alice', 'city': 'New York'}
   

3.3 Dictionary Methods

1. keys():

   • Get all keys in the dictionary.

   print(person.keys())  # Output: dict_keys(['name', 'city'])
   

2. values():

   • Get all values.

   print(person.values())  # Output: dict_values(['Alice', 'New York'])
   

3. items():

   • Get all key-value pairs.

   print(person.items())  # Output: dict_items([('name', 'Alice'), ('city', 'New York')])
   

4. Strings

Strings are sequences of characters enclosed in quotes.

4.1 Definition

• A string:
  • Immutable: Cannot be changed after creation.
  • Defined using single ' or double " quotes.

Example:

text = "Hello, world!"

4.2 Basic Operations

1. Accessing Characters:

   print(text[0])  # Output: H
   print(text[-1])  # Output: !
   

2. Slicing:

   substring = text[0:5]
   print(substring)  # Output: Hello
   

4.3 Common String Methods

1. upper(): Convert to uppercase.

   print("hello".upper())  # Output: HELLO
   

2. lower(): Convert to lowercase.

   print("HELLO".lower())  # Output: hello
   

3. strip(): Remove leading and trailing whitespace.

   print("  hello  ".strip())  # Output: hello
   

4. split(): Split the string into a list.

   print("a,b,c".split(","))  # Output: ['a', 'b', 'c']
   

5. join(): Join a list of strings into one string.

   print(",".join(["a", "b", "c"]))  # Output: a,b,c
   

4.4 String Formatting

Using f-strings:

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

Output:

My name is Alice and I am 25 years old.

Data Collections - Tuples, Dictionaries, Lists, and Strings (Additional Content)

1. The in and not in Operators in Lists and Dictionaries

The in operator is used to check if a value exists in a collection (e.g., a list or dictionary). not in does the opposite.

1.1 Usage with Lists

fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)     # True
print("grape" not in fruits) # True

• This checks whether "apple" is an element in the list.

1.2 Usage with Dictionaries

person = {"name": "Alice", "age": 25}
print("name" in person)   # True  → checks if "name" is a key
print("Alice" in person)  # False → values are not searched

• When used with a dictionary, in only checks the keys, not values.

PCEP Exam Tip:

You might see a question like:

info = {"x": 100}
print(100 in info)

• Answer: False, because 100 is a value, not a key.

2. The Safer Way to Access Dictionary Values: get()

When accessing values in a dictionary, there are two main methods:

2.1 Direct Indexing

person = {"name": "Alice"}
print(person["city"])  # Raises KeyError if "city" is not a key

• This causes an error if the key doesn’t exist.

2.2 Using .get()

print(person.get("city"))  # Returns None instead of crashing

• .get() is safer and avoids a KeyError.

PCEP Exam Tip:

You may see a question testing which line is safe to run without error. Always consider using .get() if the key might be missing.

3. Strings Are Iterable

A string in Python is an iterable object, meaning you can loop through its characters just like a list.

Example:

for ch in "hi":
    print(ch)

Output:

h  
i

This is important in the context of for loops and demonstrates that strings behave like sequences.

4. Understanding Slice Behavior in Strings vs. Lists

Slicing syntax is the same across different sequence types in Python, but the resulting data type matches the original.

String Example:

text = "abcde"
print(text[1:4])  # Output: 'bcd' (still a string)

List Example:

lst = ["a", "b", "c", "d", "e"]
print(lst[1:4])  # Output: ['b', 'c', 'd'] (still a list)

Key Concept:

• The slice returns the same type as the original sequence.

• Be cautious not to confuse string slices with list slices, especially in multiple-choice questions.

5. {} Is Not an Empty Set in Python

This is a very common misconception.

Example:

a = {}      # This is an empty dictionary
b = set()   # This is an empty set

• {} always creates a dictionary, even if it's empty.

• To create an empty set, you must use set().

Why This Matters:

Using {} when you intend to create a set can cause silent logic errors or confusion in type-checking.

Verification:

print(type({}))     # <class 'dict'>
print(type(set()))  # <class 'set'>

Summary Table

Feature	Code Example	Output	Key Takeaway
in with list	"apple" in ["apple", "banana"]	True	Checks list elements
in with dict	"name" in {"name": "Alice"}	True	Checks keys only
.get() vs []	dict.get("missing")	None	Safer than dict["missing"]
String is iterable	for ch in "hi"	hi	String acts like a sequence
String slicing	"abcde"[1:4]	'bcd'	Returns a string
List slicing	["a","b","c","d"][1:3]	['b','c']	Returns a list
Empty dictionary	{}	<class 'dict'>	Not a set!
Empty set	set()	<class 'set'>	Correct syntax