\
Python lists are a fundamental data type in Python. [They are similar to Arrays in other languages, such as Javascript](https://hackernoon.com/everything-you-need-to-know-about-javascript-arrays). You can learn more about the main [Python data structures here](https://hackernoon.com/sets-lists-dictionaries-and-tuples-in-python).

Creating a list in Python is super easy. Let's start with some of the basics, and then dive into useful ways you'll be able to work with lists. To start a new list, simply define a variable in Python, with the contents encapsulated in `[]` square brackets:

\
```python
myList = [ "some", "list", "contents" ]
```

\
As Python is a language that is dynamically typed, there are no major limitations on what can go inside a list, so feel free to add other types such as integers or floats too:

\
```python
myList = [ "some", "list", "contents", 1, 2.5, "etc" ]
```

\
Empty lists can be defined as `[]` empty square brackets should you need to do that too:

\
```python
myList = []
```

\
**Lists** can also be **nested**, or contain lists within lists (... within lists). So this is also valid python:

\
```python
myList = [ [ "some", "list" ], "inside", "a", "list" ]
```

\
Getting the length of a list is done using the standalone `len()` function. Here's an example where we try to get the length of our nested list:

\
```python
myList = [ [ "some", "list" ], "inside", "a", "list" ]
print(len(myList)) # returns 4
```

\
Finally, we can reference items in a list using the square bracket notation. For example, to get the first item of a list:

\
```python
myList = [ "some", "list", "contents", 1, 2.5, "etc" ]
print(myList[0]) # "some"
```

\
Or, to get the first two items:

\
```python
myList = [ "some", "list", "contents", 1, 2.5, "etc" ]
print(myList[0:2]) # [ "some", "list" ]
```

\
## List Methods in Python

**Lists** come with a bunch of built-in methods in Python, to allow us to fully realize their potential as data stores. These methods are:

* `list.append("newItem")` - appends an item with the value `newItem` to the end of the list.
* `list.extend(["newItem"])` - appends another iterable item onto the list, for example - combining two lists.
* `list.insert(0, "newItem")` - inserts a list item `newItem` and indexes 0. You can change the value of the index, to decide where the item should be inserted.
* `list.clear()` - deletes the contents of the list entirely.
* `list.remove("someItem")` - removes the first item of the list with a value of `item`. Will throw an error if no value `item` exists.
* `list.count("someItem")` - counts any instances of `someItem` in the list. If no item in the list has the value `someItem` then it will return 0.
* `list.copy()` - creates a shallow copy of the list.
* `list.reverse()` - reverse the elements of the list.
* `list.pop(10)` - removes an item at position 10 of the list, and returns it. If you don't define a number, it'll remove the last item, i.e. `list.pop()`.
* `list.sort()` - for sorting lists.

To bring this to life, let's look at a few examples of how it works in practice:

\
### Appending and Inserting new list items

One of the most common things you'll want to do with a list is adding new data to it. If we've created a list, we can append data using the `append` method as mentioned, or `insert` to insert items at a certain position:

\
```python
myList = [ "inside", "a", "list" ]
myList.append("friend")
myList.insert(2, "new")
print(myList); # ['inside', 'a', 'new', 'list', 'friend']
```

\
You can also add to a list using `+=`:

\
```python
myList = [ "inside", "a", "list" ]
myList += "friend"
print(myList) # ['inside', 'a', 'list', 'friend']
```

\
Or, if you have two lists, you can add the second onto the first using `extend`:

\
```python
myList = [ "some", "list" ]
otherList = [ "other", "list" ]

myList.extend(otherList)
print(myList) # ['some', 'list', 'other', 'list']
```

\
### Deleting lists and lists content

An equally common thing you'll want to do, once you add everything to your list, is to delete items. You can delete with `remove` or `clear` to simply delete the entire list:

\
```python
myList = [ "inside", "a", "list" ]
myList.remove("inside")
print(myList) # ['a', 'new']


myList.clear()
print(myList) # returns []
```

\
### Reversing a List in Python

You'll also want to reverse lists, in some situations. Python has a built-in method for this, so no need to define your own:

\
```python
myList =  [ "inside", "a", "list" ]
myList.reverse()
print(myList) # ['list', 'a', 'inside']
```

\
### Making copies of lists

In Python, we use `==` to compare by value, and `is` to compare by reference. We can use `copy()` to make a new reference for a list. This will make a new reference point in memory pointing to the same value. Below, `myList` and `otherList` are equal in value, but now their reference is different, so `myList is otherList` returns false:

\
```python
myList =  [ "a", "list" ]
otherList = myList.copy()
print(myList == otherList) # True
print(myList is otherList) # False
```

\
This can also be written as `myList[:]`, if you want to avoid using the `copy()` method:

\
```python
myList =  [ "a", "list" ]
otherList = myList[:]
print(myList == otherList) # True
print(myList is otherList) # False
```

\
### Sorting Lists in Python

Sorting a list in ascending order is easy using the `sort` function, and all items are of the same type:

\
```python
myList =  [ "a", "c", "e", "b", "f", "d", "g", "z", "w", "x" ]
myNumberList = [ 1, 3, 5, 2, 7, 4, 6 ]

myList.sort()
myNumberList.sort() 

print(myList) # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'w', 'x', 'z']
print(myNumberList) # [1, 2, 3, 4, 5, 6, 7]
```

\
If you try to sort where the list contains different types - like integers and strings, you'll end up getting an error. If you want to sort a list based on another feature of the list, you can define its `key`, and `reverse` arguments:

* `key` gives us a number that will be used to compare the list content
* `reverse` if set to true will reverse the order.

\
For example, to put all values which are `a` at the start, we could try something like this:

\
```python
def isA(letter):
    if(letter == "a"):
        return 1
    else:
        return 0

myList =  [ "a", "c", "a", 5, "f", "a", 2, "z", "a", "x" ]

myList.sort(key=isA, reverse=True)

print(myList) # ['a', 'a', 'a', 'a', 'c', 5, 'f', 2, 'z', 'x']
```

\
Here, we define a function `isA`, which takes each item in the list as its first argument (`letter`). If the letter is `a`, then it returns 1, otherwise, it returns 0. Then we reverse the list using the `reverse=True` argument, to get all the `a`s at the start.

\
### Lists function best as stacks of data!

Since lists are **ordered**, they function best as stacks, which means adding and removing items from the end of a list is super fast, while adding or removing items from the start is kind of slow. That means it's recommended to use `pop` and `append` where possible, as this is going to be a lot faster on large data sets than other methods on lists.

\
## Conclusion

Lists are super powerful data structures in Python and are used **everywhere**. You can learn more about Python data structures here. To learn more about other engineering topics, [check out the rest of my content](https://hackernoon.com/u/smpnjn). You can read more about Python data structures below:

* [Python Data Collections](https://hackernoon.com/a-complete-guide-to-python-lists)
* **Python Data Collections: Lists**
* [Python Data Collections: Tuples](https://hackernoon.com/introduction-to-tuples-in-python)
* [Python Data Collections: Sets](https://hackernoon.com/introduction-to-sets-in-python)
* [Python Data Collections: Dictionaries](https://hackernoon.com/a-complete-guide-to-python-dictionaries)

\

---

Also published [here](https://fjolt.com/article/python-lists).

Stacks

BUNCH

Super

2022 - HackerNoon Contributor of the Year - Coding

2022 - HackerNoon Contributor of the Year - Coding Skills

2022 - HackerNoon Contributor of the Year - Java

2022 - HackerNoon Contributor of the Year - Javascript

2022 - HackerNoon Contributor of the Year - Website Development

2022 - Tip Your Hat Tutorials Best Tutorials

Coding Guru of 2022

Nominated for 2022 - HackerNoon Contributor of the Year - Javascript

Nominated for 2022 - HackerNoon Contributor of the Year - Coding

Nominated for 2022 - HackerNoon Contributor of the Year - Coding Skills

Nominated for 2022 - Tip Your Hat Tutorials Best Tutorials

Nominated for 2022 - HackerNoon Contributor of the Year - Java

Nominated for 2022 - HackerNoon Contributor of the Year - Website Development

Nominated for Coding Guru of 2022

Nominated for 2022 - HackerNoon Contributor of the Year - Typescript

Too Long; Didn't Read

Cassandra Forward a free Cassandra-focused community event

A Complete Guide to Python Lists

A Complete Guide to Python Lists

Too Long; Didn't Read

People Mentioned

Companies Mentioned

Coin Mentioned

@smpnjn

RELATED STORIES