Cách thêm danh sách vào tuple trong python

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áo

Danh 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

Cách thêm danh sách vào tuple trong python
Liệt kê các chỉ số

Đâ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']
1

Hầ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

Cách thêm danh sách vào tuple trong python
Lập chỉ mục danh sách phủ định

>>>

>>> a = ['foo', 'bar', 'baz', 'qux']

>>> print(a)
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']
2

Cắ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
0

Cá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

    >>>

    >>> 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
    
    1

  • 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

    >>>

    >>> 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
    
    2

  • Bạn có thể chỉ định một bước tiến—dương hoặc â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
    
    3

  • Cú pháp để đảo ngược danh sách hoạt động giống như đối với 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
    
    4

  • Cú pháp

    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    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

    Nếu

    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    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']
    >>> b = ['baz', 'qux', 'bar', 'foo']
    >>> a == b
    False
    >>> a is b
    False
    
    >>> [1, 2, 3, 4] == [4, 1, 3, 2]
    False
    
    5

    Ngược lại, nếu

    >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
    
    6 là một danh sách, thì
    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    17 trả về một đối tượng mới là bản sao của
    >>> 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
    
    6

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ử

    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    19 và
    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    20

    >>>

    >>> 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
    
    7

  • Toán tử nối (

    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    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']
    >>> b = ['baz', 'qux', 'bar', 'foo']
    >>> a == b
    False
    >>> a is b
    False
    
    >>> [1, 2, 3, 4] == [4, 1, 3, 2]
    False
    
    8

  • Các hàm

    >>> a = ['foo', 'bar', 'baz', 'qux']
    
    >>> print(a)
    ['foo', 'bar', 'baz', 'qux']
    >>> a
    ['foo', 'bar', 'baz', 'qux']
    
    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']
    >>> b = ['baz', 'qux', 'bar', 'foo']
    >>> a == b
    False
    >>> a is b
    False
    
    >>> [1, 2, 3, 4] == [4, 1, 3, 2]
    False
    
    9

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]
1

Loại bỏ các quảng cáo

Danh 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]
2

Cấ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

Cách thêm danh sách vào tuple trong python
Danh sách lồng nhau

>>> 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]
3

Như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]
6

Khô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]
7

Tuy 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']
26

Bạ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áo

Danh 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]
0

Bạ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]
1

Mộ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]
2

Sử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]
3

Mộ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]
4

Số 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]
5

Lư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]
6

Bạ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]
7

Bạ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]
8

Chuẩ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]
9

Lư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
[, , ,
]
0

Ghi 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
[, , ,
]
1

Kế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
20

Nế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
[, , ,
]
2

Nế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
[, , ,
]
3

Phươ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
22

Nố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
[, , ,
]
4

Hã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
[, , ,
]
5

Hã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
[, , ,
]
6

Phươ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
[, , ,
]
7

Do đó, 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
30

Mở 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
[, , ,
]
9

Nó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
36

Chè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
43

Xó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
49

Xó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

  1. Bạn chỉ định chỉ mục của mục cần xóa, thay vì chính đối tượng đó
  2. 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]
3

Nế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
51

Loại bỏ các quảng cáo

Danh 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]
5

Tươ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]
6

Bộ 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 (
    >>> 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
    
    58) thay vì dấu ngoặc vuông (
    >>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
    
    5)
  • 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]
7

khô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]
8

Ghi 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]
9

Tạ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']
0

Python 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']
2

Như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']
3

Doh. 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']
4

Có 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']
5

Loại bỏ các quảng cáo

Gá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']
6

Khi đ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

Cách thêm danh sách vào tuple trong python
Tuple đóng gói

>>>

>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
7

Nế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

Cách thêm danh sách vào tuple trong python
Giải nén Tuple

>>>

>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
8

Khi 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']
0

Mộ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']
1

Trong 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']
2

Nó 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']
3

Trong 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']
4

Như 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áo

Sự 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

Cách thêm danh sách vào tuple trong python

Gửi cho tôi thủ thuật Python »

Giới thiệu về John Sturtz

Cách thêm danh sách vào tuple trong python
Cách thêm danh sách vào tuple trong python

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ề John


Mỗ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à

Cách thêm danh sách vào tuple trong python

Aldren

Cách thêm danh sách vào tuple trong python

Đan

Cách thêm danh sách vào tuple trong python

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

Cách thêm danh sách vào tuple trong python

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ẻ Email

Bà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

Chúng ta có thể thêm danh sách vào tuple trong Python không?

Chỉ có thể nối các bộ. Không thể nối nó với các loại khác như danh sách . Nếu bạn muốn nối một mục vào một bộ, bạn có thể nối một bộ với một phần tử. Lưu ý rằng một bộ có một phần tử cần có dấu phẩy ở cuối.

Chúng ta có thể thêm danh sách vào tuple không?

Sử dụng hàm có sẵn tuple() . Nếu bạn muốn chuyển đổi danh sách Python thành bộ, bạn có thể sử dụng hàm tuple() để chuyển toàn bộ danh sách làm đối số và nó sẽ .

Bạn có thể cập nhật danh sách trong một Tuple không?

Khi một bộ được tạo, bạn không thể thay đổi giá trị của nó. Các bộ dữ liệu không thể thay đổi hoặc không thay đổi vì nó còn được gọi là. Nhưng có một cách giải quyết. Bạn có thể chuyển đổi bộ dữ liệu thành danh sách, thay đổi danh sách và chuyển đổi lại danh sách thành bộ dữ liệu .