Regardless of the kind of data structure you work with,

all data structures are expected to carry out four kinds of operations at minimum.

We need to be able to access and read values stored in the structure.

We need to be able to search for an arbitrary value.

We also need to be able to inset a value at any point into the structure.

And finally, we need to be able to delete structures.

Let's look at how these operations are implemented on the array structure in some

detail starting with Access.

Elements in an array are identified using a value known as an Index.

And we use this Index to access and read the value.

Most programming languages follow a zero-based numbering system

when it comes to arrays.

And all this means is that the first index value is equal to zero, not 1.

Generally speaking, when an array is declared,

a base amount of contiguous memory is allocated as the array storage.

Computers refer to memory through the use of an address.

But instead of keeping a reference to all the memory allocated for

an array, the array only has to store the address of the first location.

Because the memory is contiguous, using the base address, the array can calculate

the address of any value by using the index position of that value as an offset.

If you want to be more specific, think of it this way.

Let's say we want to create an array of integers, and then each integer takes up

a certain amount of space in memory that we'll call M.

Let's also assume that we know how many elements we're going to create.

So the size of the array is some number of elements we'll call n.

The total amount of space that we need to allocate is n times the space per item M.

If the array keeps track of the location in memory where the first value is held,

so let's label that M0,

then it has all the information it needs to find any other element in the list.

When accessing a value in an array, we use the index.

So to get the first element in the list, we use the zero index.

To get the second we use the index value 1, and so on.

Given that the array knows how much storage is needed for each element,

it can get the address of any element by starting off with the address for

the first element.

And adding to that,the index value times the amount of storage per element.

For example, to access the second value, we can start with M0.

And to that, add times M times the index value 1,

giving us M1 as the location in memory for the second address.

This is a very simplified model, but that's more or less how it works.

This is only possible because we know that array memory is contiguous with no gaps.

Let's switch over to some code.

As I mentioned earlier, we're going to be using Python in this course.

If you don't know how to code, or you're interested in this content but

know a language other than Python, check the note section of this video for

more information.

While the code will be in Python, the concepts are universal.

And more importantly, simple enough that you should have no issue following along

in your favorite programming language.

Now, to get started, click on the Launch Workspace button

on the video page that you are watching right now.

This should spin up an instance of a treehouse workspace,

an in-browser coding environment.

Right now, your workspace should be empty, and that's to be expected.

So let's add a new file in here.

Going to go to File > New File.

And we'll call this arrays.py, py.

Creating a list in Python is quite simple.

So we'll call this new_list.

We use a set of square brackets around a set of values to create a list.

So 1.

And we comma separate them.

So space 2, and space 3.

This allocates a base amount of memory for the array to use.

Or when I say array in Python, know that I mean a list.

Since this is Python, the values aren't stored in memory.

Instead, the values 1, 2, and 3 are stored elsewhere in memory.

And the array stores references to each of those objects.

To access a value, we use a subscript along with an index value.

So to get the first value, we use the index 0.

And if we were to assign this to another variable,

it would say result equal new_list.

We write out new_list since this is the array that we're accessing the value from.

And then, a subscript notation, which is a square bracket.

And then the index value.

As we saw, since the array has a reference to the base location in memory,

the position of any element can be determined pretty easily.

We don't have to iterate over the entire list.

All we need to do is a simple calculation of an offset from the base memory

since we're guaranteed that the memory is contiguous.

For this reason, access is a constant time operation on an array or a Python list.

This is also why an array crashes if you try to access a value

using an index that is out of bounds of what the array stores.

If you've used an array before, you've undoubtedly run into an error or

a crash where you tried to access a value using an index that was larger than

the number of elements in the array.

Since the array calculates the memory address on the fly,

when you access a value with an out of bounds index, as it's called,

the memory address returned is not one that's part of the array structure.

And therefore cannot be read by the array.

In Python, this is represented by an index error.

And we can make this happen by using an index we know our array won't contain.

Now, I'm writing out my code here inside of a text editor,

which obviously doesn't run the code.

So let's drag up this console area here.

And I'm going to write python to bring up the Python interpreter.

And in here, we can do the same thing.

So I can say new_list = (1, 2, 3).

And now, this is an interpreter, so it's actually going to evaluate our code.

All right, so now, we have a new list.

If I type out new_list, it gets printed out into the console.

Okay, I can also do new_list [0], and you'll see that I get the value 1,

which is the value stored at the zeroth index.

Now, to highlight that index error, we can do new_list.

And inside the square brackets,

we can provide an index that we know our array doesn't contain.

So here I'll say index 10.

And if I hit Enter, you'll see it say index error, list index out of range.

And those are the basics of how we create and read values from an array.

In the next video, let's take a look at searching.