Lấy phần tử cuối cùng trong danh sách python

Theo dõi chúng tôi trên Fanpage để nhận thông báo mỗi khi có bài mới.

Lấy phần tử cuối cùng trong danh sách python

Facebook

Trong Python, Danh sách là kiểu dữ liệu linh hoạt nhất. Nó là một dãy các phần tử, 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ử trong dấu ngoặc vuông [ ] và ngăn cách nhau bằng dấu phẩy. Các phần tử trong danh sách được lập chỉ mục từ trái sang phải bắt đầu từ chỉ mục 0.

fruitList = [“apple”, “apricot”, “banana”,”coconut”, “lemen”]
otherList = [100, “one”, “two”, 3]
print (“Danh sách trái cây:”) print (FruitList) print (“—————————“) print (“Danh sách Khác: “) in (Danh sách khác)

Danh sách trái cây:
[‘apple’, ‘apricot’, ‘banana’, ‘coconut’, ‘lemen’]
————————— Danh sách khác:
[100, ‘one’, ‘two’, 3]

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

fruitList = [“apple”, “apricot”, “banana”, “coconut”, “lemen”, “plum”, “pear”]
cho trái cây trong fruitList: print (“Fruit:”, trái cây)

Trái cây: táo Trái cây: mơ Trái cây: chuối Trái cây: dừa Trái cây: lemen Trái cây: mận Trái cây: lê

Truy cập qua chỉ mục (index):

Bạn cũng có thể truy cập các phần tử của danh sách thông qua chỉ mục. Các phần tử của danh sách được đánh chỉ mục 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 (“Số phần tử:”, len (fruitList)) cho tôi trong phạm vi (0, len (fruitList)): print (“Phần tử at”, i, “=”, fruitList[i] ) # Một danh sách con chứa các phần tử từ chỉ mục 1 đến 4 (1, 2, 3) subList = fruitList[1: 4]
# [‘apricot’, ‘banana’, ‘coconut’]
print (“Danh sách phụ [1:4] “, subList)

[‘apple’, ‘apricot’, ‘banana’, ‘coconut’, ‘lemen’, ‘plum’, ‘pear’]

Số nguyên tố: 7 Nguyên tố ở 0 = táo Nguyên tố ở 1 = mơ Nguyên tố ở 2 = chuối Nguyên tố ở 3 = dừa Nguyên tố ở 4 = lemen Nguyên tố ở 5 = mận Nguyên tố ở 6 = lê Danh sách phụ [1:4] [‘apricot’, ‘banana’, ‘coconut’]

Bạn cũng có thể truy cập các phần tử của danh sách theo chỉ số âm (Negative index), các phần tử được đánh chỉ mục 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 (“Số phần tử:”, len (fruitList)) print (“fruitList[-1]: “, fruitList[-1]) print (“fruitList[-2]: “, fruitList[-2]) subList1 = fruitList[-4: ]
print (“\ n”) print (“Danh sách phụ fruitList[-4: ] “) print (subList1) subList2 = fruitList[-4:-2]
print (“\ n”) print (“Danh sách phụ fruitList[-4:-2] “) print (subList2)

[‘apple’, ‘apricot’, ‘banana’, ‘coconut’, ‘lemen’, ‘plum’, ‘pear’]

Số phần tử: 7 quả[-1]: quả lê[-2]: mận Danh sách phụ trái câyList[-4: ]
[‘coconut’, ‘lemen’, ‘plum’, ‘pear’]

Danh sách phụ fruitList[-4:-2]
[‘coconut’, ‘lemen’]

Ví dụ sau là cách cập nhật Danh sách theo chỉ mục:

năm = [1991,1995, 1992]
print (“Năm:”, năm) print (“Đặt năm[1] = 2000 “) năm[1] = 2000 print (“Years:”, years) print (years) print (“Nối phần tử 2015, 2016 vào danh sách”) # Nối thêm một phần tử vào cuối danh sách. years.append (2015) years.append (2016) print (“Năm:”, năm)

Năm: [1991, 1995, 1992]
Đặt năm[1] = 2000 năm: [1991, 2000, 1992]
[1991, 2000, 1992]

Nối phần tử 2015, 2016 vào danh sách Năm: [1991, 2000, 1992, 2015, 2016]

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

Một lát cắt là một số phần tử liên tiếp trong một danh sách.

Lấy phần tử cuối cùng trong danh sách python

năm = [ 1990 , 1991 , 1992 , 1993 , 1994 , 1995 , 1996 ]
print (“Năm:”, năm) print (“Cập nhật Lát: năm[1:5] = [2000, 2001]”) năm[1:5] = [ 2000 , 2001 ]
print (“Năm:”, năm)

Năm: [1990, 1991, 1992, 1993, 1994, 1995, 1996]
Cập nhật Slice: năm[1:5] = [2000, 2001]
Năm: [1990, 2000, 2001, 1995, 1996]

Để xóa một hoặc nhiều phần tử khỏi danh sách, bạn có thể sử dụng lệnh del (câu lệnh del), hoặc sử dụng phương thức gỡ bỏ(). Ví dụ dưới đây sử dụng lệnh del để loại bỏ một hoặc nhiều phần tử theo chỉ mục.

năm = [ 1990 , 1991 , 1992 , 1993 , 1994 , 1995 , 1996 ]
print (“Năm:”, năm) print (“\ n del năm[6]”) # Xóa phần tử tại chỉ mục vị trí = 6. del năm[6]
print (“Năm:”, năm) print (“\ n del năm[1:4]”) # Xóa phần tử tại chỉ mục = 1,2,3 del năm[1:4]
print (“Năm:”, năm)

Năm: [1990, 1991, 1992, 1993, 1994, 1995, 1996]
del năm[6]
Năm: [1990, 1991, 1992, 1993, 1994, 1995]
del năm[1:4]
Năm: [1990, 1994, 1995]

Phương pháp loại bỏ (giá trị) loại bỏ phần tử đầu tiên trong danh sách có giá trị bằng giá trị của tham số. Phương thức này có thể ném một ngoại lệ nếu không tìm thấy phần tử nào để loại bỏ.

năm = [ 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 years.remove (1993) print (“Years:”, years))

Năm: [1990, 1991, 1992, 1993, 1994, 1993, 1993]
years.remove (1993) Năm: [1990, 1991, 1992, 1994, 1993, 1993]

Cũng giống như Chuỗi, Danh sách có 3 toán tử +, * , in.

Nhà điều hành Mô tả Ví dụ + Toán tử dùng để ghép (nối) 2 Danh sách để tạo Danh sách mới. [1, 2, 3[ + [“One”,”Two”]-> [1, 2, 3, “One”, “Two”] * Toán tử dùng để ghép nhiều bản sao của cùng một Danh sách. Và tạo một Danh sách mới. [1, 2] * 3 -> [1, 2, 1, 2, 1, 2] trong Kiểm tra xem một phần tử có trong Danh sách hay không, kết quả trả về True hoặc False. “Abc” trong [“One”, “Abc”]-> Đúng

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 = “Ba” trong list2 print (“‘Ba’ trong list2?”, HasThree)

list1: [1, 2, 3]
list2: [‘One’, ‘Two’]
list1 + list2: [1, 2, 3, ‘One’, ‘Two’]
list2 * 3: [‘One’, ‘Two’, ‘One’, ‘Two’, ‘One’, ‘Two’]
‘Ba’ trong danh sách2? Sai

Mô tả chức năng cmp (list1, list2) So sánh các phần tử của cả hai danh sách. Chức năng này đã bị xóa 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 có giá trị lớn nhất. min (list) Trả về phần tử trong danh sách có giá trị nhỏ nhất. list (seq) Chuyển đổi một bộ giá trị thành một danh sách.

list1 = [1991, 1994, 1992]
list2 = [1991, 1994, 2000, 1992]
print (“list1:”, list1) print (“list2:”, list2) # Trả về số 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 (“Giá trị lớn nhất của list1:”, maxValue) # Giá trị nhỏ nhất trong danh sách (list). minValue = min (list1) print (“Giá trị nhỏ nhất của list1:”, minValue) # Tuple tuple3 = (2001, 2005, 2012) print (“tuple3:”, tuple3) # Chuyển 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 Giá trị lớn nhất của list1: 1994 Giá trị nhỏ nhất của 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) có kiểu số thì việc tìm giá trị nhỏ nhất và lớn nhất trong danh sách là điều dễ hiểu. Nhưng nếu danh sách chứa các phần tử thuộc loại sự vậtchúng sẽ được so sánh dựa trên quy tắc mặc định của Pythonhoặc bạn phải thiết lập một quy tắc cụ thể.

Phương thức Mô tả list.append (obj) Nối (nối) một đối tượng vào danh sách. list.count (obj) Trả về số lần xuất hiện của ‘obj’ trong list list.extend (seq) Nối nội dung của một chuỗi (chuỗi) và danh sách list.index (obj) Trả về chỉ mục nhỏ nhất trong list book tìm phần tử có giá trị là phản đối. list.insert (index, obj) Chèn một phần tử vào danh sách tại chỉ mục mục lục. list.pop ([index]) Nếu có một tham số chỉ mục, loại bỏ và trả về phần tử tại chỉ mục vị trí. Nếu không thì 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à phản đối ngoà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 được cung cấp bởi tham số.

năm = [ 1990 , 1991 , 1992 , 1993 , 1993 , 1993 , 1994 ]
print (“Năm:”, năm) print (“\ n – Đảo ngược danh sách”) # Đảo ngược danh sách. years.reverse () print (“Years (Sau khi đảo ngược):”, years) aTuple = (2001, 2002, 2003) print (“\ n – Extend:”, aTuple) years.extend (aTuple) print (“Years ( Sau khi gia hạn): “, năm) print (” \ n – Nối thêm 3000 “) năm.append (3000) print (” Năm (Sau khi bổ sung): “, năm) print (” \ n – Xoá 1993 “) năm.remove (1993) print (“Năm (Sau khi loại bỏ):”, năm) print (“\ n – years.pop ()”) # Loại bỏ phần tử cuối cùng của danh sách. lastElement = years.pop () print (“phần tử cuối cùng:”, lastElement) print (“\ n”) # Đếm print (“years.count (1993):”, years.count (1993))

Năm: [1990, 1991, 1992, 1993, 1993, 1993,1994]
– Đảo ngược danh sách Năm (Sau khi đảo ngược): [1994, 1993, 1993, 1993, 1992, 1991, 1990]
– Gia hạn: (2001, 2002, 2003) Năm (Sau khi gia hạn): [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003]
– Thêm 3000 năm (Sau khi bổ sung): [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]
– Xóa năm 1993 (Sau khi xóa): [1994, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]
– years.pop (2001) phần tử cuối cùng: 3000 năm. số lượng (1993): 2

Bài viết được chia sẻ bởi biquyet.com

Leave a Reply

Your email address will not be published.