The examples shown below work with  lists named my_list containing the following items/elements 1, '1cademy', 12.59, True.

The operator ' in ' returns true if the item is in the list otherwise false.

- Example for 'in' operator  
``` python
1 in my_list
```
output
```python
True
```
- Example for 'in' operator  
```python
12.5 in my_list
```
output
```python
False
```

'in' operator

The examples shown below work with  lists named my_list containing the following items/elements 1, '1cademy', 12.59, True.

The operator ' not in ' returns true if the particular item is not in the list otherwise false.

- Example for not in operator  
```python
1 not in my_list
```
output
```python
False
```
- Example for not in operator  
```python
12.5 not in my_list
```
output
```python
True
```


'not in' operator

The examples shown below work with  lists named my_list containing the following items/elements 1, '1cademy', 12.59, True.


The operator '*' helps to repeat the content of the list.


- Example for "*" operator 
```python
my_list*3
```
output
```python
[1,
 '1cademy',
 12.59,
 True,
 1,
 '1cademy',
 12.59,
 True,
 1,
 '1cademy',
 12.59,
 True]
```

'*' ( repetition ) operator

The examples shown below work with  lists named my_list containing the following items/elements 1, '1cademy', 12.59, True and your_list containing the items/elements such as 3.14,365,'earth',False,'i'.

The operator '+' concatenates two list or concatenates an element/items to an existing list.

- Example for "+" operator  

```python
my_list+your_list
```
output
```python
[1, '1cademy', 12.59, True, 3.14, 365, 'earth', False, 'i']
```

'+' ( concatenation ) operator

- Syntax : 
```python 
my_list[i:j]
```

- Slicing the list from i to j provide elements in the list with index k such that i <= k < j .

- If i or j is greater than length of the list then length of the list is taken.

- If i is not mentioned or None, 0 is used. 

- If j is not mentioned or None, length of the list is used. 

- The sliced list will be empty if i is greater than or equal to j.

The examples shown below work with  list named my_list containing the following items/elements 1, '1cademy', 12.59, True.



slicing the list from i to j  ( i and j are integers )

The example shows how to access each element in the list

indexing i th item of a list

- The following example shows slicing of my_list with a step.
- Syntax my_list opening square brackets i : j : k closing square brackets, i and j are the indexing integers  and k is the step.


slicing with a step

len() is used to find out the size of the list passed as an argument to the function

length of a list which is passed as the argument of the function len()

The min function returns the smallest element in a list  when the list is passed as an argument to the function.

min() ( smallest item in the list )

The max function returns the largest item in a list when the list is passed as an argument to the function.

max() ( largest item in the list )

The index function will return the index of first occurrence of a particular item in a list within the given range defined by the variables i and j.

index of an element in the list at or after an index and before another index

The count function will return the number of occurrence of a particular element in the list.

count ( total number of occurrences of a particular element in the list )


The various sequence operations on lists in ascending priority are listed below. 

- in
- not in
- "+"
- "*"
- indexing i th item of a list
- slicing the list from i to j  ( i and j are integers )
- slicing with a step
- len() ( length of a list which is passed as the argument of the function len() ) 
- min() ( smallest item in the list )
- max() ( largest item in the list )
- index of an element in the list at or after an index and before another index
- count ( total number of occurrences of a particular element in the list )

San Jose State University

- 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

Python Documentation

The list data type has the following built-in methods
- append(x)
- extend(iterable)
- insert(i, x)
- remove(x)
- pop(\[i\])
- clear()
- index(x\[, start\[, end\]\])
- count(x)
- sort(*, key=None, reverse=False)
- reverse()
- copy()

Built-in methods of Lists

Common Sequence Operations on Lists

The Map() function can be used to apply a function to a sequence of elements.


An example:
```python

def square(num):
    return num * num

my_map = map(square, [1, 3, 9])
# my_map returns -> [1, 9, 81]
```

Map() in Python

List Comprehension in Python provides an easy way to initialize and populate a list in one line. It consists of an expression followed by a ```for``` clause and an ```if```` clause if necessary. For example, if you have a list of words and want to create a list of only those words which contain the letter i, you could use the example code below.
```python
words = ["icky", "gross", "nasty", "illness", "disease"]
newWords = []

for x in words:
  if "i" in x:
    newWords.append(x)

print(newWords) #this will print: ['icky', 'illness', 'disease']
```

Learn Before

Related

Learn After