---
# System prepended metadata

title: List - mảng

---

# List - mảng

### Mảng là gì?
Là đơn vị dữ liệu với mục đích chính là nhóm nhiều giá trị lại với nhau. Tập hợp các giá trị được nhóm lại được gọi bằng cùng **một tên riêng** và được quản lí riêng biệt bằng **các chỉ số**. Mảng sinh ra giúp việc lập trình thuận tiện hơn khi phải lưu trữ nhiều giá trị có cùng một hoặc một vài tính chất.

### Tính chất
Mảng đặc trưng bởi dấu ngoặc vuông ở đầu và cuối, phần ở giữa là những dữ liệu được lưu trữ.

* Ví dụ
``` python
['day', 'la', 'du', 'lieu', 1, 2, 3, 9.67, 5.23]
```
Mỗi đơn vị dữ liệu nhỏ hơn được lưu trong mảng đều được gọi là một phần tử. Các phần tử luôn được ngăn cách với nhau bởi dấu phẩy.

Các phần tử của mảng không nhất thiết phải cùng một kiểu dữ liệu. Mảng trên đã có nhiều phần tử mang kiểu khác nhau như số nguyên (int), số thực (float), và xâu kí tự (string).

### Khai báo một mảng
Cũng tương tự như khai báo một biến mới (thường có giá trị khởi đầu là 0), khi khai báo mảng mới thường khai báo một mảng rỗng (không có chứa phần tử nào) theo cú pháp:
``` python
arr = []
```
Ở đây, mảng được khai báo mang tên ***arr*** và là một mảng rỗng. Ngoài ra nếu cần, có thể khai báo một mảng đã lưu trữ sẵn phần tử bên trong:
``` python
arr = [1, 'xaukt', 2.5]
```

### Truy cập vào độ dài của mảng
Sử dụng cú pháp tương tự như cách sử dụng với một xâu.

* Code minh họa:
``` python
arr = [1, 'xaukt', 2.5]
print(len(arr))
```
* Output
```
3
```

Ở đây xâu có 3 phần tử, nên câu lệnh in ra ***len(arr)*** sẽ in ra số ***3***

### Truy cập vào từng phần tử của mảng
Sử dụng cú pháp tương tự như cách sử dụng với một xâu.
* Code minh họa
``` python
arr = [1, 'xaukt', 2.5]
print(arr[0])
print(arr[1])
print(arr[2])
print(arr[-1])
print(arr[-3])
```

* Output
```
1
xaukt
2.5
2.5
1
```
Cách đếm chỉ số của từng phần tử mảng được bắt đầu từ số ***0*** và kết thúc ở số ***len(arr)-1***

### Nối mảng
Tương tự như xâu, mảng cũng có thể nối lại với nhau để tạo thành một mảng mới lớn hơn chứa 2 mảng cũ.
* Code minh họa
``` python
arr = [1, 2, 3]
brr = [7, 8, 9]
print(arr + brr)
print(brr + arr)
```
* Output
```
[1, 2, 3, 7, 8, 9]
[7, 8, 9, 1, 2, 3]
```
> **Lưu ý:** Tương tự như xâu, thứ tự của 2 mảng trong phép nối mảng có thể ảnh hưởng đến kết quả cuối cùng

### Cắt mảng
Phần cắt mảng tương tự như phần cắt xâu. Đây là thao tác nhằm truy cập vào một phần nhỏ hơn ở trong mảng ban đầu. Cú pháp cắt mảng có dạng như sau:
```python
arr[begin:end:step]
```

> Chú thích:
> ***begin***: một số nguyên, là chỉ số của phần tử đầu tiên trong đoạn cắt
> ***end***: một số nguyên, là chỉ số của phần tử khi gặp hoặc đi qua sẽ dừng công việc cắt xâu
> ***step***: một số nguyên khác ***0***, biểu thị khoảng cách giữa các phần tử được cắt ra từ mảng gốc

* Code minh họa:

``` python
arr = [1, 'xaukt', 2.5, 8, 19, 'chuoikt', 4.0]
print("cut 1: ", arr[:3]) 
print("cut 2: ", arr[4:]) 
print("cut 3: ", arr[1:3]) 
print("cut 4: ", arr[1:-1]) 
print("cut 5: ", arr[0:6:2]) 
print("cut 6: ", arr[::-1]) 
print("cut 7: ", arr[-4::-2])
```
* Output
```
cut 1: [1, 'xaukt', 2.5]
cut 2: [19, 'chuoikt', 4.0]
cut 3: ['xaukt', 2.5]
cut 4: ['xaukt', 2.5, 8, 19, 'chuoikt']
cut 5: [1, 2.5, 19]
cut 6: [4.0, 'chuoikt', 19, 8, 2,5, 'xaukt', 1]
cut 7: [8, 'xaukt']
```
Nếu sử dụng cú pháp này, nội dung in ra sẽ là một mảng chứ không phải là các phần tử riêng lẻ như khi truy cập vào từng phần tử một.

### Thêm phần tử vào mảng
Với một mảng có sẵn, ta có thể thêm phần tử vào phía sau của mảng bằng phương thức ***append(x)*** để mở rộng sức chứa của mảng theo ý muốn. 
* Code minh họa
``` python
arr = []
arr.append(1)
arr.append('xaukt')
arr.append(2.5)
print(arr) #In ra [1, 'xaukt', 2.5]
```
* Output
```
['TK', 2, 1, 'xaukt', 2.5]
```
Các phần tử được thêm vào sẽ được đẩy vào phía sau của mảng theo đúng thứ tự được thêm

### Chuyển từ một xâu kí tự về một mảng
Tương tự với số nguyên có hàm ***int()***, số thực có hàm ***float()***, xâu kí tự có hàm ***str()***, thì mảng có hàm ***list()***
*Code minh họa
``` python
s = 'daylamang'
arr = list(s)
print(arr)
```
* Output
```
['d', 'a', 'y', 'l', 'a', 'm', 'a', 'n', 'g']
```
Khi chuyển một xâu kí tự thành mảng, từng kí tự của xâu kí tự sẽ trở thành một phần tử của mảng.

> ## Lưu ý: 
> Mảng là kiến thức liên quan trực tiếp đến các vòng lặp thông qua phần chỉ số. Thường thì vòng lặp ***for*** sẽ được ưu tiên sử dụng để xử lí với mảng, tuy nhiên vẫn có một số trường hợp đặc biệt phải sử dụng vòng lặp ***while***. Nếu không nắm chắc về vòng lặp thì học và làm việc với mảng nhìn chung sẽ khó khăn hơn.

### Đọc vào một mảng
Các bài tập thường có đề theo dạng *"Nhập số N. Đọc vào N số tiếp theo"*. Đây là điển hình của yêu cầu nhập vào một mảng. Số ***N*** là độ dài của mảng, ***N*** số theo sau sẽ thường sẽ là các phần tử của mảng.

Để nhập một mảng khi các phần tử của mảng **mỗi dòng chỉ xuất hiện 1 phần tử**, tham khảo đoạn code sau:
``` python
n = int(input())
arr = []

for i in range(n):
    x = int(input())
    arr.append(x)
```
Số ***N*** đầu tiên được nhập vào là số phần tử của mảng cần nhập. Cần dùng vòng lặp ***for*** để có thể nhập được đúng số lượng là ***N*** phần tử tiếp theo.

Các phần tử được đọc và lưu vào biến ***x***, sau đó biến ***x*** được đẩy vào sau mảng ***arr*** đã được tạo sẵn từ trước

Ngoài ra, để nhập vào một mảng mà các phần tử mảng **nằm trên cùng một dòng**, tham khảo đoạn code sau:
``` python
n = int(input())
arr = list(map(int, input().split()))
```
Trong đoạn code trên, số ***N*** là số phần tử mảng được nhập vào trước, câu lệnh tiếp theo là sự kết hợp của câu lệnh ***map(int,input().split())*** mà đã từng được dùng để đọc nhiều số trên cùng một dòng và câu lệnh ***list()*** bao ở ngoài. 

Nếu các bạn để ý kĩ thì câu lệnh nhập mảng ***list(map(int, input().split()))*** không phụ thuộc vào số ***N***. Tuy nhiên nếu đề yêu cầu nhập số ***N*** ở trước thì phải có câu lệnh đọc một số nguyên để máy tính tiến đến phần đọc mảng phía sau.

Ở thời điểm hiện tại không khuyển khích tìm các bạn tìm hiểu sâu về cách hoạt động của câu lệnh ***list(map(int,input().split()))*** vì đây là phần kiến thức tương đối nâng cao. Bây giờ có thể hiểu nôm na đây là câu lệnh đọc vào một mảng là được.

### Duyệt mảng
Duyệt mảng là hành động truy cập vào từng phần tử của một mảng một cách tuần tự để có thể xử lí và kiểm tra tùy theo ý muốn.

#### Có 2 cách để duyệt một mảng
***Cách 1:* Duyệt qua chỉ số**

Đây là cách liệt kê từng chỉ số của mảng ra và có thể truy cập vào từng phần tử của mảng thông qua chỉ số đó. Ta sử dụng vòng lặp làm phương tiện để duyệt một mảng là ngắn gọn và dễ dàng nhất.
* Code minh họa
``` python
arr = [5, 9, 7.4, 'xaukt', 12]
    
for i in range(len(arr)):
    print(arr[i])
```
* Output
```
5
9
7.4
xaukt
12
```
Sử dụng tính chất của vòng vòng lặp ***for*** cùng câu lệnh ***range()***, biến ***i*** ở đây chạy từ giá trị ***0*** cho đến giá trị ***4*** (chính là ***len(arr)-1***). Tận dụng đặc tính này và cách đếm chỉ số của mảng, có thể truy cập đến từng phần tử của mảng bằng cú pháp ***arr[i]***.

***Cách 2:* Duyệt trực tiếp**

Đây là cách gán trực tiếp giá trị của từng phần tử vào thẳng biến đếm mà không cần thông qua chỉ số của mảng. Vòng lặp vẫn được tận dụng để duyệt mảng trong cách này.
* Code minh họa
``` python
arr = [5, 9, 7.4, 'xaukt', 12]
    
for i in arr:
    print(i)
```
* Output
```
5
9
7.4
xaukt
12
```

Cách này sử dụng câu lệnh ***in*** để gán thẳng lần lượt từng giá trị của mảng ***arr*** cho biến chạy ***i***, từ đó chỉ cần in ra biến ***i*** lúc này đang chứa các giá trị tương ứng mà không cần phải thông qua chỉ số của  từng phần tử.

> ***Lưu ý:*** tuy rằng cách 2 có điểm lợi hơn về mặt cú pháp khi phải code ít hơn (điều này sẽ giúp code nhanh hơn với những bài phức tạp khi cần truy cập vào phần tử mảng đang xét nhiều lần), tuy nhiên lại kém linh hoạt hơn cách 1 khi không thể truy cập đến các phần tử lân cận (có thể sử dụng cú pháp ***arr[i+1]***, ***arr[i-1]***,...)
> 
> => Khuyến khích học cả 2 cách dùng để có thể sử dụng trong các trường hợp khác nhau để đạt hiệu quả cao nhất

### Các phương thức với mảng

***.append(x)***: thêm phần tử có giá trị ***x*** vào cuối mảng
* Code minh họa
``` python
arr = [5, 9, 7.4, 'xaukt', 12]
arr.append(2.5)
print(arr)
```
* Output
```
[5, 9, 7.4, 'xaukt', 12, 2.5]
```
***.sort()***: sắp xếp mảng theo thứ tự tăng dần
* Code minh họa
``` python
arr = [12, 5, 9, 7.4]
arr.sort()
print(arr) #In ra [5, 7.4, 9, 12]
```
* Output
```
[5, 7.4, 9, 12]
```

> Ngoài ra mảng vẫn còn có rất nhiều phương thức và hàm xử lí khác rất hay và hữu dụng, các bạn có thể tìm đọc ở tài liệu bên ngoài.