A sequence is an ordered collection of elements, where each element is identified by an index or a key

• Homogeneous: String because each element is of the same type (a character)
• Heterogeneous: Lists because each element can be of different types.

A container type of object that can list out of the elements one by one.

Any sequence type is iterable but not all iterables is a sequence type. Iterables are more general, there is no need for positional ordering such as sets.

It will have the same memory address because tuples are immutable.There is no point in creating a new memory address when the tuple data structure will be the same.

In general, tuple is more efficient because of its immutability property. When objects are immutable they are more memory efficient, the interpreter can make certain memory optimisations, and multiple references to the same tuple can share the same memory address.

Copying a list returns a new object. However, the elements in the list that have been copied are the same objects.

If the element is mutable, when we modify either of the list’s element, both will reflect the change. This indicates that the elements in lst1 will be updated to.

Modifying a sequence in-place can lead to unintended side effects, especially when the same sequence is referenced in multiple places in the code. Copying ensures that the original data remains unchanged. This is crucial for maintaining data integrity, especially when the original data is needed elsewhere or should be preserved.

Returning the copy of the original sequence and all the object references, which means the copy container has a different object reference but the elements will have the same memory addresses as the original sequence elements.

To copy an object such that it will modifications in the copy will not affect the original even if the original object contains mutable objects.

To copy the original object recursively to copy the nested elements in the object.

• Concatenation creates a new list combining both elements of both lists.
• In-place concatenation mutates the original list, this means that the list retains the same object reference.

• Concatenation creates a new list combining both elements of both tuples.
• In-place concatenation will also create a new object reference because tuples are immutable.

An iterator is an object that allows you to iterate over collections of data, such as lists, tuples, dictionaries, and sets.

1. Return the next item from a stream or container sequentially.
2. Keeping track of the current and visited items.
3. Stop iterating when it reaches to the length of the sequence.

An object in Python is recognised as an iterator when it collectively incorporates two specific methods, known together as the iterator protocol.

• __iter__: Called to initialise the iterator. Returns the iterator object itself.
• __next__: Called to iterate over the iterator and raise the StopIteration exception when all elements have been exhausted.

• An iterable is an object with an __iter__() method, and it can be looped over using a for loop.
• An iterator is an iterable with an additional __next__() method, allowing it to fetch the next element in the sequence.

To summarise, the iterable is the collection while the iterator is responsible for iterating over the iterable/ collection

Every iterator is also an iterable, but not every iterable is an iterator in Python.

Python uses iterators to support every operation that requires iteration, including for loops, comprehensions,

Yes, iterators are exhaustive, meaning once we implement an iterator, we no longer can reuse it again.

• iter(): The function returns an iterator object.
• iterable: The collection to iterate over.
• sentinel (optional): If provided, it defines a stopping condition for the iterator. The iterator will keep calling__next__() method until the value returned matches the sentinel.

Functions that iterate through an iterable and return a single value that usually takes into account every element of the iterable.

Returns True if any (one or more) element in iterable is evaluated as True / truthy.

Returns True only if all the elements in iterables are truthy

A function that takes a single argument and returns True or False is called a predicate.

Apply predicate function to every element of the iterable to get the associated truths and then we are able to use any() or all() on the results.

Do not have to get next item in an iterable until it is actually requested.

Retrieves the next item from an iterable one at a time.

• It emits a value and the function is effectively suspended (not terminated).
• Calling next on the function resumes running the function right after the yield statement.
• If there are no more yields (exhausted), the function will return a value, if the value is not specified it will return None, which terminates the function.

A function that uses the yield statement is called the generator function. When called, a generator function returns a generator object, which is an iterator.

Generator function allows you to iterate over a potentially large sequence of values without creating the entire sequence in memory at once.

• yield retains the current state of the function, the local scope still exists.
• return exits the function and destroys the local scope.

Generators are lazy iterators because they only perform next when requested.