Python for AI 103 Warm-up

Acknowledgement: This post is based mainly on TAs Thai Nguyen and Dang Nha’s presentation and slides and partly on on TA, STA, and peers’ responses from the course AIO2025 offered by AI VIETNAM.

Relevance: The audience of this lecture were those who have read Python for AI 102, had some coding experience, and known a bit of AI knowledge. Absolute beginners are encouraged to read the material and repeatedly practice coding without AI assistance to strengthen their coding and code-reading skills. Note that only necessary Python knowledge is introduced here.

In today’s post, we’ll explore the basics of lists.

List

list_name = [element_1, ..., element_n]

Imagine a train has many wagons. If they are not connected, the train cannot run. But connecting them in an orderly fashion puts it to work. A data structure, in an analogous sense, is an efficient way of organizing and storing data in a computer system. A list is a built-in data structure. We can use it to construct user-defined data structures.

You can think of a list as an organized shopping cart that can carry literally anything. Formally, a list is a container consisting of multiple elements:

• It can be empty: a_list = [] is an empty list.
• Elements are ordered: positions of elements stay unchanged after creation unless they are updated.
• Elements are indexable: elements are associated with indices, starting from 0 at the left end.
• Elements are heterogeneous: a_list = [True, 7, "AIVIETNAM", 8.7, 7] is accepted.
• Elements can be duplicated: different elements can have the same value.

a_list = [1, 2, 3]
for item in a_list:
    print(f'value = {item}, ID = {id(item)}')

print(f'ID of a_list = {id(a_list)}')

'''
value = 1, ID = 140719557454264
value = 2, ID = 140719557454296
value = 3, ID = 140719557454328
ID of a_list = 1879354544512
'''

We can see from this example that elements of a list are discretely stored and the address of the list is entirely different.

Indexing and Slicing

The associated number mentioned above is called an index. We can use an index to query and modify the value of one element. There are two types:

• Forward index: starts at $0$ and increases by $1$ from left to right.
• Backward index: starts at $-1$ and decreases by $1$ from right to left.

a_list = [5, 6, 7, 8]
a_list[2]
>>> 7

a_list[-1]
>>> 8

Similarly, we can access the values of several continuous elements by a technique called slicing, a_list[start:end:step]. This results in a sublist

• beginning at start with $0$ by default
• increasing by step with $1$ by default
• ending before reaching end with the number of elements by default.

a_list = [5, 6, 7, 8]

# test
a_list[1:6:1]
>>> [6, 7, 8]

a_list[::2]
>>> [5, 7]

a_list[6:2:-1]
>>> [8]

a_list[-2:-4]
>>> []

a_list[1:-2]
>>> [6]

Elements of a sublist (after slicing) have the same addresses as in the original list. But changing an element’s value in the sublist does not affect the original and vice versa.

$+$ and $*$ Operators

The $+$ operator is to concatenate two lists while the $*$ operator concatenates multiple copies of a given list.

data1 = [6, 5, 7]
data2 = [1, 9, 2]

# test
data1 + data2
>>> [6, 5, 7, 1, 9, 2]

data = [6, 5]

# test
data * 3
>>> [6, 5, 6, 5, 6, 5]

List Methods

list_name.method_name(argument_if_required)

Besides accessing data, we want to manipulate it as well. Built-in methods allow us to do so. We’ll use a_list = [4, 5, 6, 7, 4, 7] for examples below.

• The append() method returns None since the only action it does is adding an element to a list.
• The same goes for the remove() method since it just deletes an element.
• However, the pop() method is to grab and throw the given value somewhere then delete it. If you want to keep that value, you can catch and carry it in a variable basket.
• We can sort() a list in the reverse order by make reverse = True as its argument.
• Assigning a list to the original list makes a copy cat—update in one affects the other. To avoid such a situation, we have the copy() method which only has the same look but is different on the inside.

a = [1, 2, 3]
b = a
b.append(4)
print(a)

a = [1, 2]
b = [3, 4]
print(a + b)

a = [1]
b = a * 3
b[0] = 0
print(a)
print(b)

a = [10, 20, 20, 30, 40, 50]
a.remove(20)
a.pop(2)
print(a)

a = [1, 2, 3, 4, 5]
print(a[-1:-3])

List Built-in Functions

• start is optional in the sum() function. It then returns the sum of all elements.
• The enumerate() function can also have start as the starting index.
• Using *iterators can save memory, avoiding memory overflow.
• Similar to the sort() method, we can sorted() a list in the reverse order by make reverse = True as its argument.

data1 = [6, 5, 7]
data2 = [1, 9, 2]

for index, value in enumerate(data1):
    print(f'enumerate: index = {index}, value = {value}')

for v1, v2 in zip(data1, data2):
    print(f'zip: v1 = {v1}, v2 = {v2}')

'''
enumerate: index = 0, value = 6
enumerate: index = 1, value = 5
enumerate: index = 2, value = 7
zip: v1 = 6, v2 = 1
zip: v1 = 5, v2 = 9
zip: v1 = 7, v2 = 2
'''

Practice and Exercises

a = [1, 2]
b = ['a', 'b, 'c']
print(list(zip(a, b)))

a = [1, [2, 3], [2, 3], 4, 5]
print(a.count([2, 3]))
print([-2: 1: -2])

FAQ

Here are some good questions asked during class. The answers to these questions came from either some admin, TA, STA, or members of AIO2025.