Code-Memo

A tuple is an ordered, mutable collection of items.

my_list = [1, 2, 3, 4, 5]

print(my_list[0])  # 1
print(my_list[-1])  # 5

print(my_list[1:3])  # [2, 3]
print(my_list[:2])  # [1, 2]
print(my_list[2:])  # [3, 4, 5]

append(): Adds an element to the end.
```
my_list.append(6)
```
insert(): Adds an element at a specific position.
```
my_list.insert(2, 'a')
```
extend(): Adds multiple elements.
```
my_list.extend([7, 8])
```

remove(): Removes the first occurrence of an element.
```
my_list.remove(2)
```
pop(): Removes and returns the element at the given index.
```
my_list.pop(1)
```
clear(): Removes all elements.
```
my_list.clear()
```

squares = [x**2 for x in range(10)]

Sorting: Use sort() for in-place sorting or sorted() to return a new sorted list. Reverse is set to True to make the sorting descending.
```
my_list.sort()
sorted_list = sorted(my_list, reverse=True)
```

Filtering: Using list comprehensions.

even_numbers = [x for x in my_list if x % 2 == 0]

Mapping: Applying a function to all elements.

squared = list(map(lambda x: x**2, my_list))

# Another example
def addition(n):
  return n + n
result = map(addition, my_list)

A tuple is an ordered, immutable collection of items.

my_tuple = (1, 2, 3)

print(my_tuple[0])  # 1
print(my_tuple[-1])  # 3

Extracting values from a tuple.

a, b, c = my_tuple

Creating Single-element Tuples: Add a comma after the element.
```
single_element_tuple = (1,)
```
Tuple Comprehensions: Using tuple() and generator expressions.
```
squared_tuple = tuple(x**2 for x in range(10))
```

Named Tuples: Creating more readable tuples using collections.namedtuple.

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # 1 2

A set is an unordered, mutable collection of unique elements.

my_set = {1, 2, 3} # my_set = set({1, 2, 3})

remove(): Removes an element (raises an error if not found).
```
my_set.remove(2)
```
discard(): Removes an element (doesn’t raise an error if not found).
```
my_set.discard(2)
```
pop(): Removes and returns an arbitrary element.
```
my_set.pop()
```
clear(): Removes all elements.
```
my_set.clear()
```

Union: Combine sets.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2  # {1, 2, 3, 4, 5}

Intersection: Elements common to both sets.
```
intersection_set = set1 & set2  # {3}
```
Difference: Elements in one set but not the other.
```
difference_set = set1 - set2  # {1, 2}
```

Symmetric Difference: Elements in either set, but not both.

symmetric_difference_set = set1 ^ set2  # {1, 2, 4, 5}

Set Comprehensions: Creating sets with a comprehension.
```
squared_set = {x**2 for x in range(10)}
```
Frozen Sets: Immutable sets.
```
frozen_set = frozenset([1, 2, 3])
```

A dictionary is an unordered, mutable collection of key-value pairs.

my_dict = {'name': 'Alice', 'age': 25}

Use keys to access values.

print(my_dict['name'])  # Alice

pop(): Removes and returns an element by key.
```
age = my_dict.pop('age')
```
popitem(): Removes and returns the last key-value pair.
```
last_item = my_dict.popitem()
```
del: Removes an element by key.
```
del my_dict['name']
```
clear(): Removes all elements.
```
my_dict.clear()
```

A brief way to create dictionaries.

squares = {x: x**2 for x in range(10)}

Iterating: Using .items(), .keys(), and .values().

for key, value in my_dict.items():
    print(key, value)

Default Values: Using get() to avoid KeyError.
```
name = my_dict.get('name', 'Unknown')
```

Merging: Combining dictionaries.

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}

Default Dictionaries: Using collections.defaultdict for automatic default values.

from collections import defaultdict
default_dict = defaultdict(int)
default_dict['a'] += 1