Dictionaries have several useful built-in methods for altering dictionary values.
- Updating/adding to a dictionary:
A dictionary can be updated by passing in an iterable object with key:value pairs (usually another dictionary) into the update method. In the example below, the "apple" key is assigned the new value "green".
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
dict.update({"apple": "green"})
```
Additionally, if a key/value pair that doesn't exist in the dictionary is passed through the update method, it is added. This is shown below.
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
dict.update({"tangerine": "orange"})
```
-Removing values from a dictionary:
There are multiple ways of removing values from a dictionary. To remove a specific item, you can use the pop or del method by passing in the key name.
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
dict.pop("banana")
del dict["apple"]
```
If you want to remove the last item in the dictionary, you can use the popitem method. 
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
dict.popitem() #There are no parameters passed in, since popitem always removes the #last item in the dictionary.
```
You can also either remove every item from the dictionary using the clear method or delete the structure itself using the del method.
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
dict.clear() #dictionary is emptied, but still exists. It can be updated with new items if you want.
del dict #dictionary is actually deleted. Referencing it again will cause an error.
```
-Looping over a dictionary
Like removing items, there are multiple ways of iterating over dictionary items depending on if you want keys, values, or both. You will iterate via a for loop and either use the key method to return only keys, the values method to return only values, or the items method to return the full key:value pair.
```python
dict = {
	"banana": "yellow",
	"apple": "red",
	"grape": "purple"
}
for x in dict.keys():
	print(x)
for x in dict.values():
	print(x)
for x, y in dict.items():
	print(x, y)
```
Other methods that may be used include:
- copy()
- fromkeys()
- get()
- setdefault()

Dictionary Methods

• Dictionary is a built-in data structure. A dictionary is an ordered and mutable collection of objects.
• It consists of Key-Value pairs. Each Key must be Unique.

Syntax:
```python
dictionary = {"key name": value}
```
```python
student_scores = {
    "John" : 76,
    "Peter": 95,
    "Mike": 84
}
```
We can access the Values using the Keys:
```python
print(student_scores["John"])
```
This ```python print() ``` statement would print out the value 76. It is also important to note that keys must map to a unique value. 


Davidson College

University of Michigan - Ann Arbor

Georgia State University

Data structures facilitate the organization of data in computer memory in an efficient manner which further support faster and more flexible data manipulations.


The python interpreter offers the following built-in data structures:


- List
- Set
- Tuple
- Dictionary


Data Structures in Python

Python Documentation

- List is a built-in data type, it is also a collection datatype(  lists accommodate elements/items of various datatype )
- List is also a sequence data type which can accommodate items of various basic data types  like integers, float etc. but usually items in a list are of same basic data type.
-  A list contains values separated by comma inside a square bracket.
- Lists are resizable. Items in a list can be added, removed and modified after the list is created.
- Lists are mutable, that means  contents of a list can be changed.
- Lists can be nested, that means we can create a list containing another list.

``` python
my_list = [1,"1cademy",12.59,True]
my_list
```
Output

``` python
[1, '1cademy', 12.59, True]
```

List

- A set is an unordered collection of data.
- The items in a set are unordered, unmutable, and cannot contain duplicate values.
- Mathematical operations (e.g. union, intersection, difference, symmetric difference) can be performed on sets.
- To create a set, list elements separated by commas within two curly braces.

Example:
```python
set = {"apple", "orange", "banana"}
```


- A tuple is a data structure that can store items within a single variable.
- The items in a tuple are ordered (indexed) and are immutable (cannot be changed).
- Tuples can have duplicate items.
- To create a tuple, surround items (separated by commas) with parentheses.
Ex:
```python
tuple = ('apple', 34, 'banana')
```
- To access an element inside a tuple, use the tuple name along with square brackets and the desired index.
Ex:
```python
tuple[1] # access tuple index 1, which is 34.
```

Tuple

Dictionary 

There are other basic data structures that are not defined in the Python standard library. These include:

- Linked List
- Stack
- Queue
- Tree
- Heap
- Graph

Learn Before

Related

Learn After