Danh sách và bộ dữ liệu được cho là loại dữ liệu hữu ích, linh hoạt nhất của Python. Bạn sẽ tìm thấy chúng trong hầu hết mọi chương trình Python thông thường
Đây là những gì bạn sẽ học trong hướng dẫn này. Bạn sẽ đề cập đến các đặc điểm quan trọng của danh sách và bộ dữ liệu. Bạn sẽ học cách xác định chúng và cách thao tác với chúng. Khi bạn hoàn thành, bạn sẽ có cảm giác tốt về thời điểm và cách sử dụng các loại đối tượng này trong chương trình Python
Lấy bài kiểm tra. Kiểm tra kiến thức của bạn với bài kiểm tra tương tác “Danh sách Python và bộ dữ liệu” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian
Lấy bài kiểm tra "
Danh sách Python
Nói tóm lại, một danh sách là một tập hợp các đối tượng tùy ý, hơi giống với một mảng trong nhiều ngôn ngữ lập trình khác nhưng linh hoạt hơn. Các danh sách được định nghĩa trong Python bằng cách đặt một chuỗi các đối tượng được phân tách bằng dấu phẩy trong dấu ngoặc vuông [
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
5], như được hiển thị bên dưới>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
Các đặc điểm quan trọng của danh sách Python như sau
- Danh sách được sắp xếp
- Danh sách có thể chứa bất kỳ đối tượng tùy ý nào
- Các phần tử danh sách có thể được truy cập theo chỉ mục
- Danh sách có thể được lồng vào độ sâu tùy ý
- Danh sách có thể thay đổi
- Danh sách động
Mỗi tính năng này được xem xét chi tiết hơn dưới đây
Loại bỏ các quảng cáoDanh sách được sắp xếp
Một danh sách không chỉ đơn thuần là một tập hợp các đối tượng. Nó là một tập hợp có thứ tự các đối tượng. Thứ tự mà bạn chỉ định các phần tử khi bạn xác định danh sách là một đặc điểm bẩm sinh của danh sách đó và được duy trì trong suốt thời gian tồn tại của danh sách đó. [Bạn sẽ thấy một kiểu dữ liệu Python không có thứ tự trong hướng dẫn tiếp theo về từ điển. ]
Các danh sách có các phần tử giống nhau theo một thứ tự khác không giống nhau
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
Danh sách có thể chứa các đối tượng tùy ý
Một danh sách có thể chứa bất kỳ loại đối tượng nào. Tất cả các phần tử của danh sách có thể cùng kiểu
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
Hoặc các phần tử có thể thuộc nhiều loại khác nhau
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
Danh sách thậm chí có thể chứa các đối tượng phức tạp, như hàm, lớp và mô-đun mà bạn sẽ tìm hiểu trong các hướng dẫn sắp tới
>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
Một danh sách có thể chứa bất kỳ số lượng đối tượng nào, từ 0 đến bao nhiêu tùy bộ nhớ máy tính của bạn cho phép
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
[Danh sách với một đối tượng đôi khi được gọi là danh sách đơn. ]
Liệt kê các đối tượng không cần phải là duy nhất. Một đối tượng nhất định có thể xuất hiện trong một danh sách nhiều lần
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
Các phần tử danh sách có thể được truy cập bằng chỉ mục
Các phần tử riêng lẻ trong danh sách có thể được truy cập bằng chỉ mục trong ngoặc vuông. Điều này hoàn toàn tương tự với việc truy cập các ký tự riêng lẻ trong một chuỗi. Lập chỉ mục danh sách dựa trên số không giống như với các chuỗi
Hãy xem xét danh sách sau đây
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
Các chỉ số cho các phần tử trong
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 được hiển thị bên dướiĐây là mã Python để truy cập một số phần tử của
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
1Hầu như mọi thứ về lập chỉ mục chuỗi hoạt động tương tự đối với danh sách. Ví dụ: chỉ mục danh sách phủ định được tính từ cuối danh sách
>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
2Cắt lát cũng hoạt động. Nếu
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 là một danh sách, biểu thức >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
9 trả về phần của >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 từ chỉ mục >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
11 đến, nhưng không bao gồm, chỉ mục >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
12>>>
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
0Các tính năng khác của việc cắt chuỗi cũng hoạt động tương tự như việc cắt danh sách
Cả hai chỉ số tích cực và tiêu cực có thể được chỉ định
>>>
1>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Việc bỏ qua chỉ mục đầu tiên sẽ bắt đầu lát cắt ở đầu danh sách và bỏ qua chỉ mục thứ hai sẽ mở rộng lát cắt đến cuối danh sách
>>>
2>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Bạn có thể chỉ định một bước tiến—dương hoặc âm
>>>
3>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Cú pháp để đảo ngược danh sách hoạt động giống như đối với chuỗi
>>>
4>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Cú pháp
13 hoạt động cho danh sách. Tuy nhiên, có một sự khác biệt quan trọng giữa cách thao tác này hoạt động với một danh sách và cách nó hoạt động với một chuỗi>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
Nếu
14 là một chuỗi, thì>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
15 trả về một tham chiếu đến cùng một đối tượng>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
>>>
5>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Ngược lại, nếu
6 là một danh sách, thì>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
17 trả về một đối tượng mới là bản sao của>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
6>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>>
6>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Một số toán tử Python và hàm tích hợp cũng có thể được sử dụng với danh sách theo cách tương tự như chuỗi
Toán tử
19 và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
20>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
>>>
7>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Toán tử nối [
21] và nhân rộng [>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
22]>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
>>>
8>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Các hàm
23,>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
24 và>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
25>>> a = ['foo', 'bar', 'baz', 'qux'] >>> print[a] ['foo', 'bar', 'baz', 'qux'] >>> a ['foo', 'bar', 'baz', 'qux']
>>>
9>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
Không phải ngẫu nhiên mà chuỗi và danh sách hoạt động giống nhau như vậy. Cả hai đều là trường hợp đặc biệt của một loại đối tượng tổng quát hơn được gọi là có thể lặp lại, mà bạn sẽ gặp chi tiết hơn trong hướng dẫn sắp tới về phép lặp xác định
Nhân tiện, trong mỗi ví dụ trên, danh sách luôn được gán cho một biến trước khi thao tác được thực hiện trên nó. Nhưng bạn cũng có thể hoạt động trên một danh sách theo nghĩa đen
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
0Đối với vấn đề đó, bạn có thể làm tương tự với một chuỗi ký tự
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
1Loại bỏ các quảng cáoDanh sách có thể lồng nhau
Bạn đã thấy rằng một phần tử trong danh sách có thể là bất kỳ loại đối tượng nào. Điều đó bao gồm một danh sách khác. Một danh sách có thể chứa các danh sách con, do đó có thể chứa chính các danh sách con, v.v. với độ sâu tùy ý
Hãy xem xét ví dụ này [được thừa nhận]
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
2Cấu trúc đối tượng mà
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
26 tham chiếu được sơ đồ hóa bên dưới>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
27, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
28 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
29 là các chuỗi, mỗi chuỗi dài một ký tự>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
3Nhưng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
00 và >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
01 là danh sách phụ>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
4Để truy cập các mục trong danh sách phụ, chỉ cần thêm một chỉ mục bổ sung
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
5>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
02 là một danh sách con khác, vì vậy việc thêm một chỉ mục nữa sẽ truy cập các phần tử của nó>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
6Không có giới hạn, không giới hạn về phạm vi bộ nhớ máy tính của bạn, về độ sâu hoặc độ phức tạp mà các danh sách có thể được lồng vào nhau theo cách này
Tất cả các cú pháp thông thường liên quan đến chỉ số và cắt cũng áp dụng cho danh sách con
>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
7Tuy nhiên, hãy lưu ý rằng các toán tử và hàm chỉ áp dụng cho danh sách ở mức bạn chỉ định và không đệ quy. Xem xét điều gì sẽ xảy ra khi bạn truy vấn độ dài của
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
26 bằng cách sử dụng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
23>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
8>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
26 chỉ có năm phần tử—ba chuỗi và hai danh sách con. Các phần tử riêng lẻ trong danh sách phụ không được tính vào độ dài của >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
26Bạn sẽ gặp tình huống tương tự khi sử dụng toán tử
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
19>>>
>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
9>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
08 không phải là một trong những phần tử trong >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
26 hoặc >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
00. Nó chỉ trực tiếp là một phần tử trong danh sách con >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
02. Một phần tử riêng lẻ trong danh sách con không được tính là phần tử của [các] danh sách mẹLoại bỏ các quảng cáoDanh sách có thể thay đổi
Hầu hết các kiểu dữ liệu bạn đã gặp cho đến nay đều là kiểu nguyên tử. Ví dụ, các đối tượng số nguyên hoặc float là các đơn vị nguyên thủy không thể chia nhỏ hơn nữa. Các loại này là bất biến, có nghĩa là chúng không thể thay đổi sau khi chúng đã được chỉ định. Thật vô nghĩa khi nghĩ đến việc thay đổi giá trị của một số nguyên. Nếu bạn muốn một số nguyên khác, bạn chỉ cần gán một số khác
Ngược lại, kiểu chuỗi là kiểu hỗn hợp. Các chuỗi có thể rút gọn thành các phần nhỏ hơn—các ký tự thành phần. Có thể hợp lý khi nghĩ đến việc thay đổi các ký tự trong một chuỗi. Nhưng bạn không thể. Trong Python, các chuỗi cũng là bất biến
Danh sách là loại dữ liệu có thể thay đổi đầu tiên bạn gặp phải. Khi một danh sách đã được tạo, các phần tử có thể được thêm, xóa, dịch chuyển và di chuyển theo ý muốn. Python cung cấp nhiều cách để sửa đổi danh sách
Sửa đổi một giá trị danh sách duy nhất
Một giá trị duy nhất trong danh sách có thể được thay thế bằng cách lập chỉ mục và gán đơn giản
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
0Bạn có thể nhớ lại từ hướng dẫn Chuỗi và dữ liệu ký tự trong Python rằng bạn không thể làm điều này với một chuỗi
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
1Một mục danh sách có thể bị xóa bằng lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
12>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
2Sửa đổi nhiều giá trị danh sách
Điều gì sẽ xảy ra nếu bạn muốn thay đổi một số phần tử liền kề trong danh sách cùng một lúc?
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
3Một lần nữa, hiện tại, hãy nghĩ về một lần lặp như một danh sách. Nhiệm vụ này thay thế lát cắt được chỉ định của
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 bằng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
14>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
4Số phần tử chèn vào không cần bằng số thay thế. Python chỉ phát triển hoặc thu nhỏ danh sách khi cần
Bạn có thể chèn nhiều phần tử thay cho một phần tử—chỉ cần sử dụng một lát cắt chỉ biểu thị một phần tử
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
5Lưu ý rằng điều này không giống như việc thay thế một phần tử bằng một danh sách
>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
6Bạn cũng có thể chèn các phần tử vào danh sách mà không cần xóa bất kỳ thứ gì. Chỉ cần chỉ định một lát cắt có dạng
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
15 [lát cắt có độ dài bằng 0] tại chỉ mục mong muốn>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
7Bạn có thể xóa nhiều phần tử ra khỏi giữa danh sách bằng cách gán lát thích hợp cho danh sách trống. Bạn cũng có thể sử dụng câu lệnh
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
12 với cùng một lát cắt>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
8Chuẩn bị hoặc thêm các mục vào danh sách
Các mục bổ sung có thể được thêm vào đầu hoặc cuối danh sách bằng cách sử dụng toán tử nối
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
21 hoặc toán tử gán tăng thêm >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
18>>>
>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
9Lưu ý rằng một danh sách phải được nối với một danh sách khác, vì vậy nếu bạn chỉ muốn thêm một phần tử, bạn cần chỉ định nó dưới dạng danh sách đơn
>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
0Ghi chú. Về mặt kỹ thuật, không hoàn toàn đúng khi nói một danh sách phải được nối với một danh sách khác. Chính xác hơn, một danh sách phải được nối với một đối tượng có thể lặp lại. Tất nhiên, danh sách có thể lặp lại, vì vậy nó hoạt động để nối một danh sách với một danh sách khác
Chuỗi cũng có thể lặp lại. Nhưng hãy xem điều gì sẽ xảy ra khi bạn nối một chuỗi vào một danh sách
>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
1Kết quả này có lẽ không hoàn toàn như bạn mong đợi. Khi một chuỗi được lặp đi lặp lại, kết quả là một danh sách các ký tự thành phần của nó. Trong ví dụ trên, những gì được nối vào danh sách
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 là danh sách các ký tự trong chuỗi >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
20Nếu bạn thực sự muốn chỉ thêm một chuỗi duy nhất
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
20 vào cuối danh sách, bạn cần chỉ định nó dưới dạng danh sách đơn lẻ>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
2Nếu điều này có vẻ bí ẩn, đừng băn khoăn quá nhiều. Bạn sẽ tìm hiểu thông tin chi tiết về các lần lặp trong hướng dẫn về phép lặp xác định
Các phương pháp sửa đổi danh sách
Cuối cùng, Python cung cấp một số phương thức tích hợp sẵn có thể được sử dụng để sửa đổi danh sách. Thông tin về các phương pháp này được trình bày chi tiết bên dưới
Ghi chú. Các phương thức chuỗi bạn đã thấy trong hướng dẫn trước không trực tiếp sửa đổi chuỗi mục tiêu. Đó là bởi vì các chuỗi là bất biến. Thay vào đó, các phương thức chuỗi trả về một đối tượng chuỗi mới được sửa đổi theo chỉ dẫn của phương thức. Họ giữ nguyên chuỗi mục tiêu ban đầu
>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
3Phương pháp danh sách là khác nhau. Vì danh sách có thể thay đổi, nên các phương thức danh sách hiển thị ở đây sẽ sửa đổi danh sách đích tại chỗ
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
22Nối một đối tượng vào một danh sách
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
22 nối thêm đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
24 vào cuối danh sách >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
4Hãy nhớ rằng, các phương thức liệt kê sửa đổi danh sách đích tại chỗ. Họ không trả về một danh sách mới
>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
5Hãy nhớ rằng khi toán tử
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
21 được sử dụng để nối vào một danh sách, nếu toán hạng đích là một toán tử có thể lặp lại, thì các phần tử của toán tử đó sẽ được tách ra và nối vào danh sách riêng lẻ>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
6Phương pháp
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
27 không hoạt động theo cách đó. Nếu một iterable được thêm vào danh sách có >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
27, nó sẽ được thêm dưới dạng một đối tượng>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
7Do đó, với
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
27, bạn có thể nối thêm một chuỗi dưới dạng một thực thể duy nhất>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
8>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
30Mở rộng danh sách với các đối tượng từ một lần lặp
Vâng, đây có lẽ là những gì bạn nghĩ nó là.
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
31 cũng thêm vào cuối danh sách, nhưng đối số được mong đợi là một đối số có thể lặp lại. Các mục trong >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
14 được thêm riêng lẻ>>>
>>> int
>>> len
>>> def foo[]:
.. pass
...
>>> foo
>>> import math
>>> math
>>> a = [int, len, foo, math]
>>> a
[, , ,
]
9Nói cách khác,
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
31 hoạt động giống như toán tử >>> a = ['foo', 'bar', 'baz', 'qux']
>>> print[a]
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
21. Chính xác hơn, vì nó sửa đổi danh sách tại chỗ, nên nó hoạt động giống như toán tử >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
18>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
0>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
36Chèn một đối tượng vào một danh sách
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
36 chèn đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
24 vào danh sách >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6 tại >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
40 đã chỉ định. Sau lời gọi phương thức, >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
41 là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
24 và các phần tử danh sách còn lại được đẩy sang bên phải>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
1>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
43Xóa một đối tượng khỏi danh sách
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
43 xóa đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
24 khỏi danh sách >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6. Nếu >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
24 không có trong >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
6, một ngoại lệ sẽ được đưa ra>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
2>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
49Xóa một phần tử khỏi danh sách
Phương pháp này khác với
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
50 theo hai cách- Bạn chỉ định chỉ mục của mục cần xóa, thay vì chính đối tượng đó
- Phương thức trả về một giá trị. mục đã được gỡ bỏ
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
51 chỉ cần xóa mục cuối cùng trong danh sách>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
3Nếu tham số
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
40 tùy chọn được chỉ định, mục tại chỉ mục đó sẽ bị xóa và trả về. >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
40 có thể âm, như với lập chỉ mục chuỗi và danh sách>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
4>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
40 mặc định là >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
55, vì vậy >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
56 tương đương với >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
51Loại bỏ các quảng cáoDanh sách động
Hướng dẫn này bắt đầu với danh sách sáu đặc điểm xác định của danh sách Python. Điều cuối cùng là danh sách động. Bạn đã thấy nhiều ví dụ về điều này trong các phần trên. Khi các mục được thêm vào danh sách, nó sẽ tăng lên khi cần thiết
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
5Tương tự như vậy, một danh sách co lại để phù hợp với việc loại bỏ các mục
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
6Bộ dữ liệu Python
Python cung cấp một loại khác là tập hợp các đối tượng được sắp xếp, được gọi là bộ
Cách phát âm khác nhau tùy thuộc vào người bạn hỏi. Một số phát âm nó như thể nó được đánh vần là “too-ple” [cùng vần với “Mott the Hoople”], và những người khác như thể nó được đánh vần là “tup-ple” [cùng vần với “supple”]. Tôi thiên về vế sau, vì nó có lẽ bắt nguồn từ cùng một nguồn gốc với “quintuple,” “sextuple,” “octuple,” v.v. ”
Định nghĩa và sử dụng Tuples
Bộ dữ liệu giống với danh sách ở mọi khía cạnh, ngoại trừ các thuộc tính sau
- Các bộ dữ liệu được xác định bằng cách đặt các phần tử trong dấu ngoặc đơn [
58] thay vì dấu ngoặc vuông [>>> a = ['foo', 'bar', 'baz', 'qux'] >>> b = ['baz', 'qux', 'bar', 'foo'] >>> a == b False >>> a is b False >>> [1, 2, 3, 4] == [4, 1, 3, 2] False
5]>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
- Tuples là bất biến
Dưới đây là một ví dụ ngắn hiển thị định nghĩa, lập chỉ mục và cắt bộ dữ liệu
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
7không bao giờ sợ hãi. Cơ chế đảo ngược chuỗi và danh sách yêu thích của chúng tôi cũng hoạt động cho các bộ dữ liệu
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
8Ghi chú. Mặc dù các bộ dữ liệu được xác định bằng cách sử dụng dấu ngoặc đơn, bạn vẫn lập chỉ mục và cắt các bộ dữ liệu bằng cách sử dụng dấu ngoặc vuông, giống như đối với chuỗi và danh sách
Mọi thứ bạn đã học về danh sách—chúng được sắp xếp theo thứ tự, chúng có thể chứa các đối tượng tùy ý, chúng có thể được lập chỉ mục và cắt lát, chúng có thể được lồng vào nhau—cũng đúng với các bộ. Nhưng chúng không thể được sửa đổi
>>>
>>> a = []
>>> a
[]
>>> a = [ 'foo' ]
>>> a
['foo']
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
.. 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
.. 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
.. 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
.. 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
9Tại sao lại sử dụng tuple thay vì danh sách?
Thực thi chương trình nhanh hơn khi thao tác một bộ dữ liệu so với danh sách tương đương. [Điều này có lẽ sẽ không đáng chú ý khi danh sách hoặc bộ dữ liệu nhỏ. ]
Đôi khi bạn không muốn dữ liệu bị sửa đổi. Nếu các giá trị trong bộ sưu tập có nghĩa là không đổi trong suốt vòng đời của chương trình, thì việc sử dụng một bộ thay vì một danh sách sẽ bảo vệ chống lại sự sửa đổi ngẫu nhiên
Có một kiểu dữ liệu Python khác mà bạn sẽ gặp ngay sau đây được gọi là từ điển, loại dữ liệu này yêu cầu một trong các thành phần của nó phải có một giá trị thuộc loại bất biến. Một bộ dữ liệu có thể được sử dụng cho mục đích này, trong khi một danh sách không thể
Trong phiên REPL của Python, bạn có thể hiển thị đồng thời các giá trị của một số đối tượng bằng cách nhập chúng trực tiếp tại dấu nhắc
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
60, được phân tách bằng dấu phẩy>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
0Python hiển thị phản hồi trong dấu ngoặc đơn vì nó đang diễn giải ngầm đầu vào dưới dạng một bộ
Có một điểm đặc biệt liên quan đến định nghĩa tuple mà bạn nên biết. Không có sự mơ hồ khi xác định một bộ trống, cũng như một bộ có hai phần tử trở lên. Python biết bạn đang định nghĩa một tuple
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
1>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
2Nhưng điều gì sẽ xảy ra khi bạn cố định nghĩa một bộ với một mục
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
3Doh. Vì dấu ngoặc đơn cũng được sử dụng để xác định thứ tự ưu tiên của toán tử trong biểu thức, nên Python đánh giá biểu thức
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
61 đơn giản là số nguyên >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
62 và tạo đối tượng >>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
63. Để nói với Python rằng bạn thực sự muốn xác định một bộ dữ liệu đơn lẻ, hãy bao gồm dấu phẩy ở cuối [>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False
>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False
64] ngay trước dấu ngoặc đơn đóng>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
4Có thể bạn sẽ không cần định nghĩa một bộ đơn lẻ thường xuyên, nhưng phải có một cách
Khi bạn hiển thị một bộ dữ liệu đơn lẻ, Python sẽ bao gồm dấu phẩy, để nhắc bạn rằng đó là một bộ dữ liệu
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
5Loại bỏ các quảng cáoGán Tuple, đóng gói và giải nén
Như bạn đã thấy ở trên, một bộ chữ chứa nhiều mục có thể được gán cho một đối tượng
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
6Khi điều này xảy ra, có vẻ như các mục trong bộ đã được “đóng gói” vào đối tượng
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
7Nếu đối tượng “đã đóng gói” đó sau đó được gán cho một bộ dữ liệu mới, thì các mục riêng lẻ sẽ được “giải nén” thành các đối tượng trong bộ dữ liệu
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
8Khi giải nén, số lượng biến bên trái phải khớp với số lượng giá trị trong bộ
>>>
>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
9Đóng gói và giải nén có thể được kết hợp thành một câu lệnh để thực hiện phép gán phức hợp
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
0Một lần nữa, số phần tử trong bộ bên trái của phép gán phải bằng số bên phải
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
1Trong các nhiệm vụ như thế này và một số tình huống nhỏ khác, Python cho phép bỏ qua các dấu ngoặc đơn thường được sử dụng để biểu thị một bộ
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
2Nó hoạt động giống nhau cho dù có bao gồm dấu ngoặc đơn hay không, vì vậy nếu bạn có bất kỳ nghi ngờ nào về việc liệu chúng có cần thiết hay không, hãy tiếp tục và bao gồm chúng
Phép gán Tuple cho phép một chút thành ngữ Python gây tò mò. Thường khi lập trình, bạn có hai biến cần hoán đổi giá trị. Trong hầu hết các ngôn ngữ lập trình, cần lưu trữ một trong các giá trị trong một biến tạm thời trong khi hoán đổi diễn ra như thế này
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
3Trong Python, việc hoán đổi có thể được thực hiện bằng một phép gán bộ dữ liệu duy nhất
>>>
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
4Như bất kỳ ai đã từng phải hoán đổi giá trị bằng biến tạm thời đều biết, có thể thực hiện theo cách này trong Python là đỉnh cao của thành tựu công nghệ hiện đại. Nó sẽ không bao giờ tốt hơn thế này
Loại bỏ các quảng cáoSự kết luận
Hướng dẫn này trình bày các thuộc tính cơ bản của danh sách và bộ dữ liệu trong Python cũng như cách thao tác với chúng. Bạn sẽ sử dụng chúng rộng rãi trong lập trình Python của mình
Một trong những đặc điểm chính của danh sách là nó được sắp xếp. Thứ tự của các phần tử trong danh sách là thuộc tính nội tại của danh sách đó và không thay đổi, trừ khi chính danh sách đó được sửa đổi. [Điều này cũng đúng với các bộ dữ liệu, ngoại trừ tất nhiên chúng không thể được sửa đổi. ]
Hướng dẫn tiếp theo sẽ giới thiệu cho bạn về từ điển Python. một kiểu dữ liệu tổng hợp không có thứ tự. đọc tiếp
Lấy bài kiểm tra. Kiểm tra kiến thức của bạn với bài kiểm tra tương tác “Danh sách Python và bộ dữ liệu” của chúng tôi. Sau khi hoàn thành, bạn sẽ nhận được điểm số để có thể theo dõi quá trình học tập của mình theo thời gian
Lấy bài kiểm tra "
« Chuỗi trong Python
Danh sách và bộ dữ liệu trong Python
Từ điển trong Python »
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Danh sách và Bộ trong Python
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về John Sturtz
John là một Pythonista cuồng nhiệt và là thành viên của nhóm hướng dẫn Real Python
» Thông tin thêm về JohnMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Aldren
Đan
Joanna
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi