Different operations can be performed on a set. Important operations include:
- Accessing a set item:

You can access all items in the set by looping over it, as shown.
```python
for x in set:
    print(x)
```
You can check if a specific value is present in the set as well.
```python
print(x in set)
```
- Adding a set item:

You can add a set item by using the add() method as shown.
```python
set.add(x)
```
You may also want to add all items from a different iterable (does not need to be a set) to your set. In this case, you may use the update method.
```python
setA = {"apple", "orange", "banana"}
setB = {"kiwi", "mango", "pineapple"}
setB.update(setA)
```
- Removing a set item:

You can remove a set item by using the remove() method as shown.
```python
set.remove(x)
```
- Joining two sets:

You can create a set that contains all the items from two sets by using the union operation. This is similar to adding all items from a different iterable, but different because rather than adding all elements from setA to setB, you are creating a new set (setC) that contains all elements of setA and setB.
```python
setA = {"apple", "orange", "banana"}
setB = {"kiwi", "mango", "pineapple"}
setC = setB.union(setA)
```
Other methods that may be used include:
- clear()
- copy()
- difference()
- discard()
- intersection()
- isdisjoint()
- issubset()
- issuperset()
- pop()
- symmetric_difference()

Set Operations

- 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"}
```


Rutgers 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 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 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. 


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