The built-in function append will insert a new element or item to the end of the list.

append(x)

The built-in function extend will add elements from another list or an iterable at the end of  current list.


extend ( iterable )

The built-in function insert will put an element in the list at the position specified by 'i'.

insert(i, x)

The built-in function remove will remove the first item in the list with the value x.
If no item exists, it raises a ValueError.


remove(x)

The built-in function pop will remove the item at the position i and return that value. If no index is provided, list.pop() will remove and return the last element of the list.

Note: square brackets around i signify that the parameter is optional.


pop([i])

The built-in function remove all elements in a list.

Calling my_list.clear() is the same as del my_list[:].

clear()

The built-in function returns the index of the first item i the list with the value x.

If no item x is found, it raises a ValueError.

Note: start and end are optional arguments. If provided, the returned index will still be relative to the beginning of the entire list, however, the start and end help to limit the search to a section of the list.

index(x[,start[,end]])

The built-in function returns the number of times an element with the value x appears in the list.

Note: If several element types are used in a list, 1 evaluates to True, so calling count(1) or count(True) counts the number of appearances of both 1's and True's. Likewise for 0's and False's.

count(x)

The built-in function sorts the list of items in place.

sort(*, key = None, reverse = False)

The built-in function reverses the list of items in place.

reverse()

The built-in function returns a shallow copy of the list.

Note: my_list.copy() is equivalent to my_list[:]

copy()

Lists can be used as stacks by using append() to add an item to the top, and pop() without an index to retrieve the element from the top.

Example:

Mimicking Stacks with Lists

With the given index of the element to remove, you can delete an item by calling del on the list indexed at the element's index. Unlike pop(), this simply removes the element without returning the value. 

del can also be used to remove an entire list or slices in the same way as the pop() method.

Removing an element from a list: del vs. pop()

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()

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

Built-in methods of Lists

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 )

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