Hướng dẫn difference between string and tuple in python - sự khác biệt giữa chuỗi và tuple trong python

Bốn loại đối tượng chính bạn sẽ làm việc là chuỗi, danh sách, từ điển và bộ dữ liệu. Biết cách thao túng các đối tượng này là vô cùng quan trọng trong Python. Trước khi thảo luận chi tiết về từng đối tượng, tôi muốn đưa ra một cái nhìn tổng quan về bốn đối tượng.

Definitions:

• Đúng
• Không

• >>> len(['a', 'b', 'c', 'd'])
  4
  >>> len((2, 4, 6, 8, 10, 12))
  6
  >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
  >>> len(pairs)
  3
  

  5 Nhà điều hành?keys and values where there is a mapping between a given key and its corresponding value. There is no order to the set of keys and values.
• Áp dụng phương pháp?

Một chuỗi là một chuỗi các ký tự.

• Danh sách một chuỗi các giá trị có thể là ký tự, số nguyên hoặc thậm chí một danh sách khác (được gọi là danh sách lồng nhau).immutable. When using strings, bracket operators cannot be used on the left side of an assignment with the intention of changing that string.
• Từ điển là một phiên bản tổng quát hơn của một danh sách và được tạo thành một tập hợp các khóa và giá trị trong đó có ánh xạ giữa một khóa nhất định và giá trị tương ứng của nó. Không có thứ tự cho tập hợp các khóa và giá trị.mutable. Unlike strings, you can use the bracket operator on the left side of the assignment to change an element in a given list.
• Một tuple là một chuỗi các giá trị (bất kỳ loại nào) làm cho chúng tương tự như danh sách, nhưng sự khác biệt là chúng là bất biến.mutable. You can modify any item (key-value pair) in a dictionary using the bracket operator on the left side of the assignment.
• Immutable Vs có thể thay đổi:immutable. You can extract elements, but you cannot modify elements of a tuple on the left side of the assignment operator.

Chuỗi là bất biến. Khi sử dụng chuỗi, các toán tử khung không thể được sử dụng ở phía bên trái của một gán với mục đích thay đổi chuỗi đó.

Danh sách là có thể thay đổi. Không giống như chuỗi, bạn có thể sử dụng toán tử khung ở phía bên trái của nhiệm vụ để thay đổi một phần tử trong một danh sách nhất định.

• Từ điển là có thể thay đổi. Bạn có thể sửa đổi bất kỳ mục nào (cặp giá trị khóa) trong từ điển bằng toán tử khung ở phía bên trái của bài tập.
• Tuples là bất biến. Bạn có thể trích xuất các yếu tố, nhưng bạn không thể sửa đổi các phần tử của một bộ dữ liệu ở phía bên trái của toán tử gán.

Toán tử

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

5:

Toán tử

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

• Khi so sánh hai chuỗi, toán tử tìm kiếm nếu chuỗi đầu tiên xuất hiện dưới dạng chuỗi con trong lần thứ hai và trả về

  >>> len(['a', 'b', 'c', 'd'])
  4
  >>> len((2, 4, 6, 8, 10, 12))
  6
  >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
  >>> len(pairs)
  3
  

  9 hoặc

  >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
  >>> last = seq[len(seq)]       # ERROR!
  

  0.
• Nếu đối số thứ hai là danh sách, toán tử có thể lấy hai chuỗi và danh sách để xem chuỗi có xuất hiện dưới dạng một trong các phần tử trong danh sách và trả về

  >>> len(['a', 'b', 'c', 'd'])
  4
  >>> len((2, 4, 6, 8, 10, 12))
  6
  >>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
  >>> len(pairs)
  3
  

  9 hoặc

  >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
  >>> last = seq[len(seq)]       # ERROR!
  

  0 không.
• Hàm len:
• Hàm

  >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
  >>> last = seq[len(seq)]       # ERROR!
  

  3 có thể được sử dụng để:

Tính độ dài của chuỗi

Tính số lượng các phần tử trong danh sáchdot notation. The syntax is the name of the objects followed by a dot (or period) followed by the name of the method.

x = "Hello Boston!"
x.split()

Tính số lượng các mục (cặp giá trị khóa) trong từ điển

Tính toán các phần tử số trong tuple

Các phương thức cho từng loại đối tượng (ký hiệu dấu chấm)

1. Đối với chuỗi, danh sách và từ điển, có tập hợp các phương thức bạn có thể sử dụng để thao tác các đối tượng. Bởi vì các bộ dữ liệu là bất biến, không có phương pháp nào để sửa đổi các đối tượng. Nói chung, ký hiệu cho các phương thức là ký hiệu dấu chấm. Cú pháp là tên của các đối tượng theo sau là một dấu chấm (hoặc khoảng thời gian) theo sau là tên của phương thức.
2. Ở đây chúng tôi sử dụng phương thức

   >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
   >>> last = seq[len(seq)]       # ERROR!
   

   4 được áp dụng cho một chuỗi (biến điều này thành phương thức chuỗi). Phương thức phân tách chuỗi tại một dấu phân cách nhất định (trong trường hợp này là không gian trắng).
3. Khi nào nên sử dụng đối tượng nào?

Trong các trang tiếp theo, tôi sẽ so sánh và đối chiếu sự tương đồng và khác biệt của chuỗi, danh sách, từ điển và bộ dữ liệu chi tiết hơn. Nói chung, các danh sách phổ biến hơn các bộ dữ liệu (chủ yếu là vì chúng có thể thay đổi), nhưng có một vài lý do tại sao các bộ đếm có thể được ưa thích hơn:

Trong một số bối cảnh, giống như một câu lệnh trả về, việc tạo một tuple đơn giản hơn về mặt cú pháp hơn là một danh sách. Trong các bối cảnh khác, bạn có thể thích một danh sách.

3.1. Các loại dữ liệu trình tựSequence data types¶

Chương trước, chúng tôi đã giới thiệu các loại tích hợp Python,

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Số nguyên và phao là các loại số, có nghĩa là chúng giữ số. Chúng ta có thể sử dụng các toán tử số mà chúng ta đã thấy chương cuối cùng với chúng để tạo thành các biểu thức số. Trình thông dịch Python sau đó có thể đánh giá các biểu thức này để tạo ra các giá trị số, làm cho Python trở thành một máy tính rất mạnh.numeric types, which means they hold numbers. We can use the numeric operators we saw last chapter with them to form numeric expressions. The Python interpreter can then evaluate these expressions to produce numeric values, making Python a very powerful calculator.

Chuỗi, danh sách và bộ dữ liệu đều là các loại trình tự, vì vậy được gọi là vì chúng hoạt động như một chuỗi - một bộ sưu tập các đối tượng được đặt hàng.sequence types, so called because they behave like a sequence - an ordered collection of objects.

Các loại squence khác nhau về mặt chất lượng với các loại số vì chúng là loại dữ liệu hỗn hợp - có nghĩa là chúng được tạo thành từ các mảnh nhỏ hơn. Trong trường hợp chuỗi, chúng được tạo thành từ các chuỗi nhỏ hơn, mỗi chuỗi chứa một ký tự. Ngoài ra còn có chuỗi trống, không chứa ký tự nào cả.compound data types - meaning they are made up of smaller pieces. In the case of strings, they’re made up of smaller strings, each containing one character. There is also the empty string, containing no characters at all.

Trong trường hợp danh sách hoặc bộ dữ liệu, chúng được tạo thành từ các phần tử, là giá trị của bất kỳ kiểu dữ liệu Python nào, bao gồm các danh sách và bộ dữ liệu khác.elements, which are values of any Python datatype, including other lists and tuples.

Danh sách được đặt trong ngoặc vuông (

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

Một danh sách không chứa các phần tử được gọi là một danh sách trống và một tuple không có phần tử là một tuple trống.

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Ví dụ đầu tiên là danh sách năm số nguyên, và tiếp theo là danh sách ba chuỗi. Thứ ba là một tuple chứa bốn số nguyên, sau đó là một tuple chứa bốn chuỗi. Cuối cùng là một danh sách chứa ba bộ dữ liệu, mỗi bộ chứa một cặp chuỗi.

Tùy thuộc vào những gì chúng tôi đang làm, chúng tôi có thể muốn coi một loại dữ liệu hỗn hợp là một điều duy nhất hoặc chúng tôi có thể muốn truy cập các phần của nó. Sự mơ hồ này là hữu ích.

Ghi chú

Có thể bỏ dấu ngoặc đơn khi chỉ định một tuple và chỉ sử dụng danh sách các giá trị bị phân tách bằng dấu phẩy:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Ngoài ra, bắt buộc phải bao gồm một dấu phẩy khi chỉ định một tuple chỉ có một yếu tố:

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Ngoại trừ trường hợp của tuple trống, nó thực sự là dấu phẩy, không phải dấu ngoặc đơn, nói với Python rằng đó là một tuple.

3.2. Làm việc với các phần của chuỗiWorking with the parts of a sequence¶

Các loại trình tự chia sẻ một tập hợp các hoạt động chung.

3.2.1. Lập chỉ mụcIndexing¶

Toán tử lập chỉ mục (

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Biểu thức

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

Bạn có thể dự kiến ​​sẽ thấy

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

3.2.2. Chiều dài¶Length¶

Chương trước bạn đã thấy hàm

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

Với danh sách và bộ dữ liệu,

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> len(['a', 'b', 'c', 'd'])
4
>>> len((2, 4, 6, 8, 10, 12))
6
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> len(pairs)
3

3.2.3. Truy cập các yếu tố ở cuối chuỗiAccessing elements at the end of a sequence¶

Người ta thường thấy trong chương trình máy tính cần truy cập các yếu tố ở cuối chuỗi. Bây giờ bạn đã thấy chức năng

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Điều đó đã giành được công việc. Nó gây ra lỗi thời gian chạy

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

Vì chúng tôi bắt đầu đếm ở 0, mười sáu chỉ số được đánh số từ 0 đến 15. Để có được phần tử cuối cùng, chúng tôi phải trừ 1 từ độ dài:

>>> last = seq[len(seq) - 1]

Đây là một mô hình phổ biến như vậy mà Python cung cấp một ký hiệu tay ngắn cho nó, lập chỉ mục âm, đếm ngược từ cuối chuỗi.negative indexing, which counts backward from the end of the sequence.

Biểu thức

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

>>> prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
>>> prime_nums[-2]
29
>>> classmates = ("Alejandro", "Ed", "Kathryn", "Presila", "Sean", "Peter")
>>> classmates[-5]
'Ed'
>>> word = "Alphabet"
>>> word[-3]
'b'

3.2.4. Traversal và prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 0 Loop¶Traversal and the prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 0 loop¶

Rất nhiều tính toán liên quan đến việc xử lý một chuỗi một yếu tố tại một thời điểm. Mẫu phổ biến nhất là bắt đầu ở đầu, lần lượt chọn từng phần tử, làm điều gì đó với nó và tiếp tục cho đến khi kết thúc. Mô hình xử lý này được gọi là một đường truyền.traversal.

Vòng lặp Python từ ____990 giúp Traversal dễ dàng thể hiện:

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Ghi chú

Chúng tôi sẽ thảo luận về việc lặp lại chi tiết hơn trong chương tiếp theo. Bây giờ, chỉ cần lưu ý rằng dấu hai chấm (:) ở cuối dòng đầu tiên và thụt vào dòng thứ hai đều được yêu cầu để câu lệnh này được chính xác về mặt cú pháp.

3.3. ________ 92¶prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] for num in prime_nums: print(num ** 2) 2¶

Khi vòng lặp

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.3.1. Lát cắtSlices¶

Một phần sau của một chuỗi được gọi là một lát cắt và hoạt động trích xuất một phần sau được gọi là cắt. Giống như với việc lập chỉ mục, chúng tôi sử dụng dấu ngoặc vuông (

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

>>> last = seq[len(seq) - 1]

>>> last = seq[len(seq) - 1]

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Nhà điều hành

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

Nếu bạn bỏ qua chỉ mục đầu tiên (trước dấu hai chấm), lát cắt bắt đầu ở đầu chuỗi. Nếu bạn bỏ qua chỉ mục thứ hai, lát cắt đi đến cuối chuỗi. Do đó:

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Bạn nghĩ

prime_nums = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

for num in prime_nums:
    print(num ** 2)

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Các chỉ số tiêu cực cũng được cho phép, vì vậy

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Mẹo

Phát triển sự hiểu biết vững chắc về cách cắt lát hoạt động là quan trọng. Tiếp tục tạo các thử nghiệm trên mạng của riêng bạn với các chuỗi và lát cắt cho đến khi bạn có thể liên tục dự đoán kết quả của một hoạt động cắt trước khi bạn chạy nó.

Khi bạn cắt một chuỗi, chuỗi kết quả luôn có cùng loại với trình tự mà nó được bắt nguồn. Điều này nói chung không đúng với việc lập chỉ mục, ngoại trừ trong trường hợp chuỗi.

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Mặc dù các yếu tố của một danh sách (hoặc tuple) có thể thuộc bất kỳ loại nào, bất kể bạn cắt nó như thế nào, một lát của danh sách là một danh sách.

3.3.2. Nhà điều hành [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 01The [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 01 operator¶

Toán tử

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Lưu ý rằng một chuỗi là một chuỗi con của chính nó và chuỗi trống là một chuỗi con của bất kỳ chuỗi nào khác. (Cũng lưu ý rằng các lập trình viên máy tính thích nghĩ về các trường hợp cạnh này khá cẩn thận!)

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.4. Đối tượng và Phương phápObjects and methods¶

Chuỗi, danh sách và bộ dữ liệu là đối tượng, điều đó có nghĩa là chúng không chỉ giữ các giá trị, mà còn có các hành vi tích hợp được gọi là phương thức, hoạt động trên các giá trị trong đối tượng.

Hãy cùng xem xét một số phương thức chuỗi trong hành động để xem cách thức hoạt động của nó.

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Bây giờ, hãy để học cách mô tả những gì chúng ta vừa thấy. Mỗi chuỗi trong các ví dụ trên được theo sau bởi một toán tử chấm, tên phương thức và danh sách tham số, có thể trống.dot operator, a method name, and a parameter list, which may be empty.

Trong ví dụ đầu tiên, chuỗi

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Trong ví dụ thứ tư, phương thức

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.5. Hàm [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 21 và DocStrings¶The [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 21 function and docstrings¶

Phần trước đã giới thiệu một số phương thức của các đối tượng chuỗi. Để tìm tất cả các phương pháp mà các chuỗi có, chúng ta có thể sử dụng chức năng

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Chúng tôi sẽ hoãn việc nói về những người bắt đầu bằng cách nhấn mạnh gấp đôi (

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Sử dụng thông tin này, chúng tôi có thể thử sử dụng phương thức thay thế để biến đổi mà chúng tôi biết nó hoạt động như thế nào.

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Ví dụ đầu tiên thay thế tất cả các tình trạng của

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.6. [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 30 và [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 31 Phương pháp Jor[10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 30 and [10, 20, 30, 40, 50] ["spam", "bungee", "swallow"] (2, 4, 6, 8) ("two", "four", "six", "eight") [("cheese", "queso"), ("red", "rojo"), ("school", "escuela")] 31 methods¶

Có hai phương pháp phổ biến cho cả ba loại chuỗi:

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Chúng tôi sẽ khám phá các chức năng này trong các bài tập.

3.7. Danh sách là có thể thay đổiLists are mutable¶

Không giống như các chuỗi và bộ dữ liệu, là các đối tượng bất biến, danh sách có thể thay đổi, điều đó có nghĩa là chúng ta có thể thay đổi các yếu tố của chúng. Sử dụng toán tử khung ở phía bên trái của bài tập, chúng tôi có thể cập nhật một trong các yếu tố:mutable, which means we can change their elements. Using the bracket operator on the left side of an assignment, we can update one of the elements:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Toán tử khung được áp dụng cho một danh sách có thể xuất hiện ở bất cứ đâu trong một biểu thức. Khi nó xuất hiện ở phía bên trái của một bài tập, nó thay đổi một trong các yếu tố trong danh sách, do đó, phần tử đầu tiên của

>>> last = seq[len(seq) - 1]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Nhưng nó làm cho danh sách:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Với toán tử lát cắt, chúng tôi có thể cập nhật một số yếu tố cùng một lúc:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Chúng tôi cũng có thể xóa các phần tử khỏi danh sách bằng cách gán danh sách trống cho họ:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Và chúng ta có thể thêm các phần tử vào danh sách bằng cách ép chúng vào một lát trống tại vị trí mong muốn:

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

3.8. Danh sách xóaList deletion¶

Sử dụng các lát để xóa các yếu tố danh sách có thể khó xử, và do đó dễ bị lỗi. Python cung cấp một giải pháp thay thế dễ đọc hơn.

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Như bạn có thể mong đợi,

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Bạn có thể sử dụng một lát làm chỉ mục cho

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Như thường lệ, các lát cắt chọn tất cả các yếu tố lên đến, nhưng không bao gồm chỉ số thứ hai.

3.9. Phương pháp liệt kêList methods¶

Ngoài

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Phương pháp

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.10. Tên và các giá trị có thể thay đổiNames and mutable values¶

Nếu chúng tôi thực hiện các câu lệnh gán này,

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Chúng tôi biết rằng các tên

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> last = seq[len(seq) - 1]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Có hai trạng thái có thể:

hoặc

Trong một trường hợp,

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Chúng ta có thể kiểm tra xem hai tên có cùng giá trị bằng cách sử dụng

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Chúng ta có thể kiểm tra xem hai tên có đề cập đến cùng một đối tượng bằng toán tử IS hay không:

Điều này cho chúng ta biết rằng cả

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.11. Răng cưa¶Aliasing¶

Vì các biến đề cập đến các đối tượng, nếu chúng ta gán một biến cho một biến khác, cả hai biến tham chiếu đến cùng một đối tượng:

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Trong trường hợp này, đây là thứ hai trong hai sơ đồ trạng thái mô tả mối quan hệ giữa các biến.

Bởi vì cùng một danh sách có hai tên khác nhau,

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Mặc dù hành vi này có thể hữu ích, đôi khi nó bất ngờ hoặc không mong muốn. Nói chung, sẽ an toàn hơn khi tránh răng cưa khi bạn đang làm việc với các đối tượng có thể thay đổi. Tất nhiên, đối với các đối tượng bất biến, không có vấn đề gì, vì chúng có thể thay đổi sau khi chúng được tạo ra.

3.12. Danh sách nhân bảnCloning lists¶

Nếu chúng tôi muốn sửa đổi một danh sách và cũng giữ một bản sao của bản gốc, chúng tôi cần có thể tạo một bản sao của danh sách, không chỉ là tài liệu tham khảo. Quá trình này đôi khi được gọi là nhân bản, để tránh sự mơ hồ của bản sao từ.cloning, to avoid the ambiguity of the word copy.

Cách dễ nhất để sao chép danh sách là sử dụng toán tử lát cắt:

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Lấy bất kỳ lát cắt

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

Bây giờ chúng tôi có thể tự do thay đổi

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

3.13. Danh sách lồng nhauNested lists¶

Danh sách lồng nhau là một danh sách xuất hiện dưới dạng một yếu tố trong một danh sách khác. Trong danh sách này, phần tử có chỉ mục 3 là một danh sách lồng nhau:

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Nếu chúng ta in

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Hoặc chúng ta có thể kết hợp chúng:

Các toán tử khung đánh giá từ trái sang phải, do đó, biểu thức này có phần tử ba eth của

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

3.14. Chuỗi và danh sáchStrings and lists¶

Python có một số công cụ kết hợp danh sách các chuỗi thành các chuỗi và các chuỗi riêng biệt thành danh sách các chuỗi.

Lệnh

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> singleton = (2,)
>>> type(singleton)

>>> not_tuple = (2)
>>> type(not_tuple)

>>> empty_tuple = ()
>>> type(empty_tuple)

Phương thức

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Ở đây chúng tôi có

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Lưu ý rằng dấu phân cách không xuất hiện trong danh sách.

Phương pháp

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Giá trị chuỗi mà phương thức

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

Dấu tách cũng có thể là chuỗi trống.

>>> fruit = "banana"
>>> fruit[1]
'a'
>>> fruits = ['apples', 'cherries', 'pears']
>>> fruits[0]
'apples'
>>> prices = (3.99, 6.00, 10.00, 5.25)
>>> prices[3]
5.25
>>> pairs = [('cheese', 'queso'), ('red', 'rojo'), ('school', 'escuela')]
>>> pairs[2]
('school', 'escuela')

3.15. Tuple Ghépter¶Tuple assignment¶

Thỉnh thoảng, rất hữu ích khi trao đổi các giá trị của hai biến. Với các câu lệnh gán thông thường, chúng tôi phải sử dụng một biến tạm thời. Ví dụ, để hoán đổi

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]

[10, 20, 30, 40, 50]
["spam", "bungee", "swallow"]
(2, 4, 6, 8)
("two", "four", "six", "eight")
[("cheese", "queso"), ("red", "rojo"), ("school", "escuela")]