Trong python, phương thức dùng để thêm phần tử vào cuối list:

Cấu trúc dữ liệu cơ bản nhất trong Python là dãy [sequence]. Mỗi phần tử trong dãy được gán một số, là vị trí hoặc chỉ mục của nó. Chỉ mục đầu tiên là 0, chỉ mục thứ hai là 1, và …

Python có sáu kiểu dãy đã được xây dựng sẵn, và trong loạt bài này chúng ta sẽ tìm hiểu hai kiểu được sử dụng phổ biến nhất là List và Tuple.

List trong Python là cấu trúc dữ liệu mà có khả năng lưu giữ các kiểu dữ liệu khác nhau.

List trong Python là thay đổi [mutable], nghĩa là Python sẽ không tạo một List mới nếu bạn sửa đổi một phần tử trong List.

List là một container mà giữ các đối tượng khác nhau trong một thứ tự đã cho. Các hoạt động khác nhau như chèn hoặc xóa có thể được thực hiện trên List.

Một List có thể được tạo ra bởi lưu trữ một dãy các kiểu giá trị khác nhau được phân biệt bởi các dấu phảy. Dưới đây là cú pháp để tạo List:

=[giatri1, giatri2, ..., giatriN];

Ví dụ:

list1 = ['vatly', 'hoahoc', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"];

Một List trong Python được bao xung quanh bởi các dấu ngoặc vuông [].

Tương tự như chỉ mục của chuỗi, chỉ mục của List bắt đầu từ 0.

Truy cập các giá trị trong List trong Python

Để truy cập các giá trị trong List, bạn sử dụng cú pháp sau:

[index]

để lấy giá trị có sẵn tại chỉ mục đó.

Ví dụ:

list1 = ['vatly', 'hoahoc', 1997, 2000]; list2 = [1, 2, 3, 4, 5, 6, 7 ]; print "list1[0]: ", list1[0] print "list2[1:5]: ", list2[1:5]

Khi code trên được thực thi sẽ cho kết quả:

list1[0]: vatly list2[1:5]: [2, 3, 4, 5]

Ghi chú: Trình tổ chức bộ nhớ nội tại

List không lưu trữ các phần tử một cách trực tiếp tại chỉ mục. Sự thực là một tham chiếu được lưu trữ tại mỗi chỉ mục mà tham chiếu tới đối tượng được lưu trữ ở đâu đó trong bộ nhớ. Điều này là do một số đối tượng có thể lớn hơn một số đối tượng khác và vì thế chúng được lưu trữ tại một vị trí bộ nhớ khác.

Các hoạt động cơ bản trên List trong Python

Bạn có thể thực hiện các hoạt động nối với toán tử + hoặc hoạt động lặp với * như trong các chuỗi. Điểm khác biệt là ở đây nó tạo một List mới, không phải là một chuỗi.

Ví dụ cho nối List:

list1=[10,20] list2=[30,40] list3=list1+list2 print list3

Kết quả là:

>>> [10, 20, 30, 40] >>>

Ghi chus: Toán tử + ngụ ý rằng cả hai toán hạng được truyền cho nó phải là List, nếu không sẽ cho một lỗi như ví dụ sau:

list1=[10,20] list1+30 print list1

Kết quả là:

Traceback [most recent call last]: File "C:/Python27/lis.py", line 2, in list1+30

Ví dụ cho lặp List:

list1=[10,20] print list1*1

Kết quả là:

>>> [10, 20] >>>

Cập nhật List trong Python

Bạn có thể cập nhật một hoặc nhiều phần tử của List bởi gán giá trị cho chỉ mục cụ thể đó. Cú pháp:

[index]=

Ví dụ:

list = ['vatly', 'hoahoc', 1997, 2000]; print "Gia tri co san tai chi muc thu 2 : " print list[2] list[2] = 2001; print "Gia tri moi tai chi muc thu 2 : " print list[2]

Khi code trên được thực thi sẽ cho kết quả:

Gia tri co san tai chi muc thu 2 : 1997 Gia tri moi tai chi muc thu 2 : 2001

Phụ thêm phần tử vào cuối một List

Phương thức append[] được sử dụng để phụ thêm phần tử vào cuối một List. Cú pháp:

.append[item]

Ví dụ:

list1=[10,"hoang",'z'] print "Cac phan tu cua List la: " print list1 list1.append[10.45] print "Cac phan tu cua List sau khi phu them la: " print list1

Khi code trên được thực thi sẽ cho kết quả:

>>> Cac phan tu cua List la: [10, 'hoang', 'z'] Cac phan tu cua List sau khi phu them la: [10, 'hoang', 'z', 10.45] >>>

Xóa phần tử trong List

Để xóa một phần tử trong List, bạn có thể sử dụng lệnh del nếu bạn biết chính xác phần tử nào bạn muốn xóa hoặc sử dụng phương thức remove[] nếu bạn không biết. Ví dụ:

list1 = ['vatly', 'hoahoc', 1997, 2000]; print list1 del list1[2]; print "Cac phan tu cua List sau khi xoa gia tri tai chi muc 2 : " print list1

Khi code trên được thực thi sẽ cho kết quả:

['vatly', 'hoahoc', 1997, 2000] Cac phan tu cua List sau khi xoa gia tri tai chi muc 2 : ['vatly', 'hoahoc', 2000]

Bạn cũng có thể sử dụng del để xóa tất cả phần tử từ chi_muc_bat_dau tới chi_muc_ket_thuc như sau:

list1=[10,'hoang',50.8,'a',20,30] print list1 del list1[0] print list1 del list1[0:3] print list1

Khi code trên được thực thi sẽ cho kết quả:

>>> [10, 'hoang', 50.8, 'a', 20, 30] ['hoang', 50.8, 'a', 20, 30] [20, 30] >>>

Các hàm và phương thức đã xây dựng sẵn để xử lý List trong Python

Ngoài các phương thức kể trên, Python còn xây dựng sẵn rất nhiều hàm và phương thức để bạn có thể sử dụng khi làm việc với List. Bảng dưới đây liệt kê các phương thức này. Bạn truy cập link để thấy ví dụ chi tiết.

Danh sách các hàm xử lý List trong Python:

Danh sách các phương thức xử lý List trong Python:

Hãy theo dõi chúng tôi trên Fanpage để nhận được thông báo mỗi khi có bài viết mới.
Facebook

Trong Python, List là một kiểu dữ liệu linh hoạt nhất.  Nó là dẫy [sequence] phần tử [element], nó cho phép loại bỏ, hoặc thêm các phần tử vào danh sách, đồng thời cho phép cắt lát [Slice] các phần tử.

Để viết một danh sách, bạn đặt các phần tử nằm trong cặp ngoặc vuông [ ] và ngăn cách nhau bởi dấu phẩy. Các phần tử trong danh sách được đánh chỉ số [index] từ trái sang phải bắt đầu từ chỉ số 0.

fruitList = ["apple", "apricot", "banana","coconut", "lemen"] otherList = [100, "one", "two", 3] print ["Fruit List:"] print [fruitList] print [" --------------------------- "] print ["Other List:"] print [otherList]

Fruit List: ['apple', 'apricot', 'banana', 'coconut', 'lemen'] --------------------------- Other List: [100, 'one', 'two', 3]

Sử dụng vòng lặp for để truy cập vào các phần tử của danh sách:

fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"] for fruit in fruitList : print ["Fruit: ", fruit]

Fruit: apple Fruit: apricot Fruit: banana Fruit: coconut Fruit: lemen Fruit: plum Fruit: pear

Truy cập thông qua chỉ số [index]:

Bạn cũng có thể truy cập vào các phần tử của list thông qua chỉ số. Các phần tử của list được đánh chỉ số từ trái sang phải, bắt đầu từ 0.

fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"] print [ fruitList ] # Số phần tử. print ["Element count: ", len[fruitList] ] for i in range [0, len[fruitList] ] : print ["Element at ", i, "= ", fruitList[i] ] # Một danh sách con chứa các phần tử từ index 1 đến 4 [1, 2, 3] subList = fruitList[1: 4] # ['apricot', 'banana', 'coconut'] print ["Sub List [1:4] ", subList ]

['apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear'] Element count: 7 Element at 0 = apple Element at 1 = apricot Element at 2 = banana Element at 3 = coconut Element at 4 = lemen Element at 5 = plum Element at 6 = pear Sub List [1:4] ['apricot', 'banana', 'coconut']

Bạn cũng có thể truy cập vào các phần tử của danh sách theo chỉ số âm [Negative index], các phần tử được đánh chỉ số từ phải sang trái với các giá trị -1, -2, ...

fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"] print [ fruitList ] print ["Element count: ", len[fruitList] ] print ["fruitList[-1]: ", fruitList[-1]] print ["fruitList[-2]: ", fruitList[-2]] subList1 = fruitList[-4: ] print ["\n"] print ["Sub List fruitList[-4: ] "] print [subList1] subList2 = fruitList[-4:-2] print ["\n"] print ["Sub List fruitList[-4:-2] "] print [subList2]

['apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear'] Element count: 7 fruitList[-1]: pear fruitList[-2]: plum Sub List fruitList[-4: ] ['coconut', 'lemen', 'plum', 'pear'] Sub List fruitList[-4:-2] ['coconut', 'lemen']

Ví dụ dưới đây là cách cập nhật List theo chỉ số [index]:

years = [1991,1995, 1992] print ["Years: ", years] print ["Set years[1] = 2000"] years[1] = 2000 print ["Years: ", years] print [ years ] print ["Append element 2015, 2016 to list"] # Nối [append] thêm một phần tử vào cuối danh sách. years.append[ 2015 ] years.append[ 2016 ] print ["Years: ", years]

Years: [1991, 1995, 1992] Set years[1] = 2000 Years: [1991, 2000, 1992] [1991, 2000, 1992] Append element 2015, 2016 to list Years: [1991, 2000, 1992, 2015, 2016]

Bạn cũng có thể cập nhập giá trị cho một lát [Slice] các phần tử. Đây là cách để bạn cập nhập nhiều phần tử một lúc.

Một lát [Slice] là một vài phần tử có vị trí liên tiếp nhau trong một danh sách.

years = [ 1990 , 1991 , 1992 , 1993 , 1994 , 1995 , 1996 ] print ["Years: ", years] print ["Update Slice: years[1:5] = [2000, 2001]"] years[1:5] = [ 2000 , 2001 ] print ["Years: ", years]

Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996] Update Slice: years[1:5] = [2000, 2001] Years: [1990, 2000, 2001, 1995, 1996]

Để xóa một hoặc nhiều phần tử trong một danh sách [list] bạn có thể sử dụng lệnh del [del statement], hoặc sử dụng phương thức remove[]. Ví dụ dưới đây sử dụng lệnh del để xóa một hoặc nhiều phần tử theo chỉ số.

years = [ 1990 , 1991 , 1992 , 1993 , 1994 , 1995 , 1996 ] print ["Years: ", years] print ["\n del years[6]"] # Xóa phần tử tại vị trí có index = 6. del years[6] print ["Years: ", years] print ["\n del years[1:4]"] # Xóa phần tử tại index = 1,2,3 del years[1:4] print ["Years: ", years]

Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996] del years[6] Years: [1990, 1991, 1992, 1993, 1994, 1995] del years[1:4] Years: [1990, 1994, 1995]

Phương thức remove[value] loại bỏ phần tử đầu tiên trong danh sách có giá trị bằng với giá trị của tham số. Phương thức này có thể ném ra ngoại lệ [throw exception] nếu không tìm thấy phần tử nào để loại bỏ.

years = [ 1990 , 1991 , 1992 , 1993 , 1994 , 1993 , 1993 ] print ["Years: ", years] print ["\n years.remove[1993]"] # Loại bỏ phần tử đầu tiên có giá trị 1993 trong danh sách years.remove[1993] print ["Years: ", years]

Years: [1990, 1991, 1992, 1993, 1994, 1993, 1993] years.remove[1993] Years: [1990, 1991, 1992, 1994, 1993, 1993]

Cũng giống như String, List có 3 toán tử +, * , in.

Toán tử Mô tả Ví dụ
+ Toán tử sử dụng để nối [concatenate] 2 List để tạo ra một List mới. [1, 2, 3[ + ["One","Two"]
--> [1, 2, 3, "One", "Two"]
* Toán tử sử dụng để nối [concatenate] nhiều bản copy của cùng một List. Và tạo ra một List mới. [1, 2] * 3
--> [1, 2, 1, 2, 1, 2]
in Kiểm tra một phần tử có nằm List hay không, kết quả trả về True hoặc False. "Abc" in ["One", "Abc"]
--> True

list1 = [1, 2, 3] list2 = ["One", "Two"] print ["list1: ", list1] print ["list2: ", list2] print ["\n"] list12 = list1 + list2 print ["list1 + list2: ", list12] list2x3 = list2 * 3 print ["list2 * 3: ", list2x3] hasThree = "Three" in list2 print ["'Three' in list2? ", hasThree]

list1: [1, 2, 3] list2: ['One', 'Two'] list1 + list2: [1, 2, 3, 'One', 'Two'] list2 * 3: ['One', 'Two', 'One', 'Two', 'One', 'Two'] 'Three' in list2? False

Hàm Mô tả
cmp[list1, list2] So sánh các phần tử của cả 2 danh sách. Hàm này đã bị xóa bỏ khỏi Python3.
len[list] Trả về số phần tử của danh sách
max[list] Trả về phần tử trong danh sách với giá trị lớn nhất.
min[list] Trả về phần tử trong danh sách với giá trị nhỏ nhất.
list[seq] Chuyển đổi một tuple thành danh sách.

list1 = [1991, 1994, 1992] list2 = [1991, 1994, 2000, 1992] print ["list1: ", list1] print ["list2: ", list2] # Trả về số lượng phần tử của danh sách. print ["len[list1]: ", len[list1] ] print ["len[list2]: ", len[list2] ] # Giá trị lớn nhất trong danh sách [list]. maxValue = max[list1] print ["Max value of list1: ", maxValue] # Giá trị nhỏ nhất trong danh sách [list]. minValue = min[list1] print ["Min value of list1: ", minValue] # Tuple tuple3 = [2001, 2005, 2012] print ["tuple3: ", tuple3] # Chuyển đổi một Tuple thành List. list3 = list [tuple3] print ["list3: ", list3]

list1: [1991, 1994, 1992] list2: [1991, 1994, 2000, 1992] len[list1]: 3 len[list2]: 4 Max value of list1: 1994 Min value of list1: 1991 tuple3: [2001, 2005, 2012] list3: [2001, 2005, 2012]

Nếu các phần tử của một danh sách [list] là kiểu số, việc tìm giá trị nhỏ nhất và lớn nhất trong danh sách là dễ hiểu. Nhưng nếu danh sách chứa các phần tử có kiểu là object, chúng sẽ được so sánh dựa trên quy tắc mặc định của Python, hoặc bạn phải đặt ra một quy tắc cụ thể.

Phương thức Mô tả
list.append[obj] Nối [append] một đối tượng vào danh sách.
list.count[obj] Trả về số lần xuất hiện 'obj' trong danh sách
list.extend[seq] Nối nội dung của một dẫy [sequence] và danh sách
list.index[obj] Trả về chỉ số nhỏ nhất trong danh sách tìm thấy phần tử có giá trị là obj.
list.insert[index, obj] Trèn một phần tử vào danh sách tại chỉ số index.
list.pop[[index]] Nếu có tham số index, loại bỏ và trả về phần tử tại vị trí index. Ngược lại loại bỏ và trả về phần tử cuối cùng của danh sách.
list.remove[obj] Loại bỏ phần tử đầu tiên có giá trị là obj ra khỏi danh sách.
list.reverse[] Đảo ngược các phần tử trong danh sách
list.sort[key=None, reverse=False] Sắp xếp các phần tử theo khóa [key] cung cấp bởi tham số.

years = [ 1990 , 1991 , 1992 , 1993 , 1993 , 1993 , 1994 ] print ["Years: ", years] print ["\n - Reverse the list"] # Đảo ngược danh sách. years.reverse[] print ["Years [After reverse]: ", years] aTuple = [2001, 2002, 2003] print ["\n - Extend: ", aTuple] years.extend[aTuple] print ["Years [After extends]: ", years] print ["\n - Append 3000"] years.append[3000] print ["Years [After appends]: ", years] print ["\n - Remove 1993"] years.remove[1993] print ["Years [After remove]: ", years] print ["\n - years.pop[]"] # Loại bỏ phần tử cuối cùng của danh sách. lastElement = years.pop[] print ["last element: ", lastElement] print ["\n"] # Count print ["years.count[1993]: ",years.count[1993] ]

Years: [1990, 1991, 1992, 1993, 1993, 1993,1994] - Reverse the list Years [After reverse]: [1994, 1993, 1993, 1993, 1992, 1991, 1990] - Extend: [2001, 2002, 2003] Years [After extends]: [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003] - Append 3000 Years [After appends]: [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000] - Remove 1993 Years [After remove]: [1994, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000] - years.pop[2001] last element: 3000 years.count[1993]: 2

Video liên quan

Chủ Đề