# Assign a list to an variable named my_list
my_list = [1,2,3]

"""
Explanation: Lists
Earlier when discussing strings we introduced the concept of a sequence in Python. Lists can be thought of the most general version of a sequence in Python. Unlike strings, they are mutable, meaning the elements inside a list can be changed!
In this section we will learn about:
1.) Creating lists
2.) Indexing and Slicing Lists
3.) Basic List Methods
4.) Nesting Lists
5.) Introduction to List Comprehensions

Lists are constructed with brackets [] and commas separating every element in the list.
Let's go ahead and see how we can construct lists!
End of explanation
"""


my_list = ['A string',23,100.232,'o']

"""
Explanation: We just created a list of integers, but lists can actually hold different object types. For example:
End of explanation
"""


len(my_list)

"""
Explanation: Just like strings, the len() function will tell you how many items are in the sequence of the list.
End of explanation
"""


my_list = ['one','two','three',4,5]

# Grab element at index 0
my_list[0]

# Grab index 1 and everything past it
my_list[1:]

# Grab everything UP TO index 3
my_list[:3]

"""
Explanation: Indexing and Slicing
Indexing and slicing works just like in strings. Let's make a new list to remind ourselves of how this works:
End of explanation
"""


my_list + ['new item']

"""
Explanation: We can also use + to concatenate lists, just like we did for strings.
End of explanation
"""


my_list

"""
Explanation: Note: This doesn't actually change the original list!
End of explanation
"""


# Reassign
my_list = my_list + ['add new item permanently']

my_list

"""
Explanation: You would have to reassign the list to make the change permanent.
End of explanation
"""


# Make the list double
my_list * 2

# Again doubling not permanent
my_list

"""
Explanation: We can also use the * for a duplication method similar to strings:
End of explanation
"""


# Create a new list
l = [1,2,3]

"""
Explanation: Basic List Methods
If you are familiar with another programming language, you might start to draw parallels between arrays in another language and lists in Python. Lists in Python however, tend to be more flexible than arrays in other languages for a two good reasons: they have no fixed size (meaning we don't have to specify how big a list will be), and they have no fixed type constraint (like we've seen above).
Let's go ahead and explore some more special methods for lists:
End of explanation
"""


# Append
l.append('append me!')

# Show
l

"""
Explanation: Use the append method to permanently add an item to the end of a list:
End of explanation
"""


# Pop off the 0 indexed item
l.pop(0)

# Show
l

# Assign the popped element, remember default popped index is -1
popped_item = l.pop()

popped_item

# Show remaining list
l

"""
Explanation: Use pop to "pop off" an item from the list. By default pop takes off the last index, but you can also specify which index to pop off. Let's see an example:
End of explanation
"""


l[100]

"""
Explanation: It should also be noted that lists indexing will return an error if there is no element at that index. For example:
End of explanation
"""


new_list = ['a','e','x','b','c']

#Show
new_list

# Use reverse to reverse order (this is permanent!)
new_list.reverse()

new_list

# Use sort to sort the list (in this case alphabetical order, but for numbers it will go ascending)
new_list.sort()

new_list

"""
Explanation: We can use the sort method and the reverse methods to also effect your lists:
End of explanation
"""


# Let's make three lists
lst_1=[1,2,3]
lst_2=[4,5,6]
lst_3=[7,8,9]

# Make a list of lists to form a matrix
matrix = [lst_1,lst_2,lst_3]

# Show
matrix

"""
Explanation: Nesting Lists
A great feature of of Python data structures is that they support nesting. This means we can have data structures within data structures. For example: A list inside a list.
Let's see how this works!
End of explanation
"""


# Grab first item in matrix object
matrix[0]

# Grab first item of the first item in the matrix object
matrix[0][0]

"""
Explanation: Now we can again use indexing to grab elements, but now there are two levels for the index. The items in the matrix object, and then the items inside that list!
End of explanation
"""


# Build a list comprehension by deconstructing a for loop within a []
first_col = [row[0] for row in matrix]

first_col

"""
Explanation: List Comprehensions
Python has an advanced feature called list comprehensions. They allow for quick construction of lists. To fully understand list comprehensions we need to understand for loops. So don't worry if you don't completely understand this section, and feel free to just skip it since we will return to this topic later.
But in case you want to know now, here are a few examples!
End of explanation
"""


