Hướng dẫn tuple parameter python - tham số tuple python

Trong bài viết này, chúng ta sẽ học cách vượt qua một bộ các yếu tố như một lập luận cho một chức năng trong Python. Chúng tôi sẽ sử dụng một số mã tùy chỉnh để hiểu rõ hơn về chủ đề .. Trước tiên chúng ta hãy xem nhanh những gì là một tuple trong Python.

Python tuple

Python có một loại dữ liệu tích hợp được gọi là một tuple. Dữ liệu bên trong một tuple có thể thuộc bất kỳ loại nào nói, số nguyên, chuỗi hoặc giá trị float hoặc thậm chí là một loại tuple. Bộ tuple sử dụng các giá trị được phân tách bằng dấu phẩy trong dấu ngoặc tròn hoặc dấu ngoặc đơn để lưu trữ dữ liệu. Tuples có thể được xác định bằng bất kỳ tên biến nào và sau đó gán các giá trị khác nhau cho bộ dữ liệu bên trong dấu ngoặc tròn. Bộ tuple được đặt hàng, không thể thay đổi và cho phép các giá trị trùng lặp.

tuple1 = ("Ram", "Arun", "Kiran")
tuple2 = (16, 78, 32, 67)
tuple3 = ("apple", "mango", 16, "cherry", 3.4)

Chuyển một tuple như một đối số cho một hàm

Trong Python, một tuple được xác định với nhiều yếu tố được phân tách bằng dấu phẩy trong ngoặc đơn hoặc dấu ngoặc tròn. Dấu ngoặc đơn phân biệt một tuple với các loại dữ liệu khác như danh sách, từ điển, v.v. Nhưng, các tiêu chuẩn ngôn ngữ Python nói rằng dấu ngoặc đơn không bắt buộc đối với một tuple.

Dưới ba trường hợp là tương đương và biểu thị một tuple trong Python. Để thuận tiện cho người dùng, Python xây dựng một bộ tạm thời khi cần thiết cho một câu lệnh gán. Do đó, cả ba câu lệnh gán đều giống hệt nhau khi chúng đạt được chuyển động dữ liệu.

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2

Ví dụ: Truyền một tuple làm đối số bằng cách sử dụng *args cú pháp

Phương pháp truyền một tuple như một đối số cho một hàm liên quan đến phương pháp giải nén. Giải nén trong Python sử dụng cú pháp

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
7. Vì các chức năng có thể lấy một số lượng đối số tùy ý, chúng tôi sử dụng toán tử giải nén
def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
8 để giải nén đối số duy nhất vào nhiều đối số. Đây là một cách đặc biệt để nhận các tham số cho một hàm như một tuple. Do * tiền tố trên biến ARGS, tất cả các đối số bổ sung được truyền cho hàm được lưu trữ trong Args dưới dạng tuple.

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))


25

Ví dụ: Truyền một tuple như một đối số như một biến riêng lẻ

Một tuple cũng có thể được truyền như một đối số duy nhất cho hàm. Các bộ dữ liệu cá nhân là đối số chỉ là các biến riêng lẻ. Một cuộc gọi chức năng không phải là một câu lệnh gán; Đó là một bản đồ tham chiếu. Do đó, ngữ nghĩa là khác nhau. Trong ví dụ dưới đây, cuộc gọi hàm đầu tiên xác định rõ ràng bộ tuple bằng cách sử dụng một biến và sau đó chuyển biến làm đối số. Một cuộc gọi chức năng khác vượt qua tuple được đặt trong khung tròn thay vì xác định rõ ràng nó.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))


2 2
2

Sự kết luận

Trong bài viết này, chúng tôi đã sử dụng hai ví dụ để hiểu làm thế nào chúng ta có thể chuyển một tuple như một đối số cho một hàm. Chúng tôi đã thảo luận về cú pháp

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
7 trong Python để giải nén các đối số của tuple và sử dụng chúng một cách riêng biệt trong cơ thể chức năng và một phương pháp khác liên quan đến việc xác định rõ ràng Tuple và sau đó chuyển nó như một đối số.

Chương này mô tả một số điều mà bạn đã học được về chi tiết hơn và thêm một số điều mới.

5.1. Thêm về Danh sáchMore on Lists¶

Kiểu dữ liệu danh sách có một số phương pháp khác. Dưới đây là tất cả các phương thức của các đối tượng danh sách:

list.append(x)append(x)

Thêm một mục vào cuối danh sách. Tương đương với

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
0.

list.extend(iterable)extend(iterable)

Mở rộng danh sách bằng cách nối thêm tất cả các mục từ Itable. Tương đương với

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
1.

list.insert (i, x)insert(i, x)

Chèn một mục tại một vị trí nhất định. Đối số đầu tiên là chỉ số của phần tử trước đó để chèn, do đó

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
2 chèn ở phía trước danh sách và
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
3 tương đương với
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
4.

list.remove(x)remove(x)

Xóa mục đầu tiên khỏi danh sách có giá trị bằng x. Nó tăng

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
5 nếu không có mặt hàng như vậy.

list.pop([i])pop([i])

Loại bỏ mục tại vị trí đã cho trong danh sách và trả về nó. Nếu không có chỉ mục được chỉ định,

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
6 sẽ xóa và trả về mục cuối cùng trong danh sách. .

list.clear()clear()

Xóa tất cả các mục khỏi danh sách. Tương đương với

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
7.

list.index (x [, start [, end]]))index(x[, start[, end]])

Trả về chỉ mục dựa trên 0 trong danh sách mục đầu tiên có giá trị bằng x. Tăng

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
5 nếu không có mặt hàng như vậy.

Các đối số tùy chọn bắt đầu và kết thúc được giải thích là trong ký hiệu lát cắt và được sử dụng để giới hạn tìm kiếm ở một phần trăm cụ thể của danh sách. Chỉ số được trả về được tính toán liên quan đến đầu của chuỗi đầy đủ thay vì đối số bắt đầu.

list.count(x)count(x)

Trả về số lần x xuất hiện trong danh sách.

list.sort (*, key = none, lùi = sai)sort(*, key=None, reverse=False)

Sắp xếp các mục của danh sách tại chỗ (các đối số có thể được sử dụng để sắp xếp sắp xếp, xem

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
9 để giải thích của họ).

list.reverse()reverse()

Đảo ngược các yếu tố của danh sách tại chỗ.

list.copy()copy()

Trả lại một bản sao nông của danh sách. Tương đương với

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
0.

Một ví dụ sử dụng hầu hết các phương thức danh sách:

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

Bạn có thể nhận thấy rằng các phương thức như

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
1,
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
2 hoặc
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
3 chỉ sửa đổi danh sách không có giá trị trả về được in - chúng trả lại
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
4 mặc định. 1 Đây là một nguyên tắc thiết kế cho tất cả các cấu trúc dữ liệu có thể thay đổi trong Python.

Một điều khác bạn có thể nhận thấy là không phải tất cả dữ liệu có thể được sắp xếp hoặc so sánh. Chẳng hạn,

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5 không sắp xếp vì các số nguyên có thể được so sánh với các chuỗi và không ai có thể so sánh với các loại khác. Ngoài ra, có một số loại don don có mối quan hệ đặt hàng xác định. Ví dụ,
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
6 là một so sánh hợp lệ.

5.1.1. Sử dụng danh sách như Stacks¶Using Lists as Stacks¶

Các phương thức danh sách giúp việc sử dụng danh sách như một ngăn xếp rất dễ dàng, trong đó phần tử cuối cùng được thêm vào là phần tử đầu tiên được truy xuất (lần cuối cùng, lần đầu tiên, ra mắt). Để thêm một mục vào đầu ngăn xếp, hãy sử dụng

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
7. Để lấy một mục từ đầu ngăn xếp, hãy sử dụng
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
8 mà không có chỉ mục rõ ràng. Ví dụ:

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2. Sử dụng danh sách như hàng đợiUsing Lists as Queues¶

Cũng có thể sử dụng một danh sách như một hàng đợi, trong đó phần tử đầu tiên được thêm vào là phần tử đầu tiên được truy xuất (từ đầu tiên, lần đầu tiên); Tuy nhiên, danh sách không hiệu quả cho mục đích này. Mặc dù các lần nối và bật từ cuối danh sách rất nhanh, nhưng việc chèn hoặc bật từ đầu danh sách là chậm (vì tất cả các yếu tố khác phải được thay đổi bởi một).

Để thực hiện hàng đợi, hãy sử dụng

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
9 được thiết kế để có sự thay đổi nhanh chóng và bật từ cả hai đầu. Ví dụ:

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3. Danh sách toàn diệnList Comprehensions¶

Danh sách toàn diện cung cấp một cách ngắn gọn để tạo danh sách. Các ứng dụng phổ biến là tạo ra các danh sách mới trong đó mỗi yếu tố là kết quả của một số hoạt động được áp dụng cho từng thành viên của một chuỗi khác hoặc có thể lặp lại hoặc tạo ra một phần trăm của các yếu tố đáp ứng một điều kiện nhất định.

Ví dụ: giả sử chúng tôi muốn tạo một danh sách các ô vuông, như:

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Lưu ý rằng điều này tạo ra (hoặc ghi đè) một biến có tên

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
0 vẫn tồn tại sau khi vòng lặp hoàn thành. Chúng ta có thể tính toán danh sách các ô vuông mà không cần bất kỳ tác dụng phụ nào bằng cách sử dụng:

squares = list(map(lambda x: x**2, range(10)))

Hoặc, tương đương:

squares = [x**2 for x in range(10)]

đó là ngắn gọn và dễ đọc hơn.

Một danh sách hiểu bao gồm các dấu ngoặc chứa một biểu thức theo sau là mệnh đề

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1, sau đó không hoặc nhiều hơn
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1 hoặc
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
3. Kết quả sẽ là một danh sách mới do đánh giá biểu thức trong bối cảnh của các điều khoản
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1 và
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
3 theo nó. Ví dụ, ListComp này kết hợp các yếu tố của hai danh sách nếu chúng không bằng nhau:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
0

Và nó tương đương với:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
1

Lưu ý cách thứ tự của các câu lệnh

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1 và
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
3 giống nhau trong cả hai đoạn này.

Nếu biểu thức là một tuple (ví dụ:

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
8 trong ví dụ trước), nó phải được đặt dấu ngoặc đơn.

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
2

Danh sách các hệ thống có thể chứa các biểu thức phức tạp và các hàm lồng nhau:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
3

5.1.4. Danh sách lồng nhau toàn diệnNested List Comprehensions¶

Biểu thức ban đầu trong khả năng hiểu danh sách có thể là bất kỳ biểu thức tùy ý nào, bao gồm cả sự hiểu biết danh sách khác.

Hãy xem xét ví dụ sau đây của ma trận 3x4 được triển khai dưới dạng danh sách 3 danh sách độ dài 4:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
4

Danh sách hiểu biết sau đây sẽ chuyển đổi các hàng và cột:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
5

Như chúng ta đã thấy trong phần trước, sự hiểu biết trong danh sách bên trong được đánh giá trong bối cảnh của

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
1 theo sau, vì vậy ví dụ này tương đương với:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
6

Điều này, đến lượt nó, giống như:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
7

Trong thế giới thực, bạn nên thích các chức năng tích hợp hơn cho các câu lệnh dòng chảy phức tạp. Hàm

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0 sẽ làm rất tốt cho trường hợp sử dụng này:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
8

Xem danh sách đối số giải nén để biết chi tiết về dấu hoa thị trong dòng này.Unpacking Argument Lists for details on the asterisk in this line.

5.2. Tuyên bố >>> squares = [] >>> for x in range(10): ... squares.append(x**2) ... >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 1The >>> squares = [] >>> for x in range(10): ... squares.append(x**2) ... >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 1 statement¶

Có một cách để xóa một mục khỏi danh sách được đưa ra chỉ mục của nó thay vì giá trị của nó: câu lệnh

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1. Điều này khác với phương thức
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
8 trả về giá trị. Câu lệnh
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1 cũng có thể được sử dụng để xóa các lát khỏi danh sách hoặc xóa toàn bộ danh sách (mà chúng tôi đã làm trước đó bằng cách gán một danh sách trống cho lát cắt). Ví dụ:

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
9

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1 cũng có thể được sử dụng để xóa toàn bộ biến:

Tham khảo tên

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
6 sau đây là một lỗi (ít nhất là cho đến khi một giá trị khác được gán cho nó). Chúng tôi sẽ tìm thấy các công dụng khác cho
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1 sau.

5.3. Tuples and Streak¶Tuples and Sequences¶

Chúng tôi đã thấy rằng các danh sách và chuỗi có nhiều thuộc tính chung, chẳng hạn như các hoạt động lập chỉ mục và cắt lát. Chúng là hai ví dụ về các loại dữ liệu chuỗi (xem các loại trình tự - danh sách, tuple, phạm vi). Vì Python là một ngôn ngữ phát triển, các loại dữ liệu trình tự khác có thể được thêm vào. Ngoài ra còn có một loại dữ liệu trình tự tiêu chuẩn khác: Tuple.Sequence Types — list, tuple, range). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.

Một tuple bao gồm một số giá trị được phân tách bằng dấu phẩy, ví dụ:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
0

Như bạn thấy, trên các bộ dữ liệu đầu ra luôn được đặt trong ngoặc đơn, do đó các bộ dữ liệu lồng nhau được giải thích chính xác; Chúng có thể là đầu vào có hoặc không có dấu ngoặc đơn xung quanh, mặc dù dù sao cũng thường là dấu ngoặc đơn (nếu tuple là một phần của biểu thức lớn hơn). Không thể gán cho các mục riêng lẻ của một tuple, tuy nhiên có thể tạo các bộ dữ liệu có chứa các đối tượng có thể thay đổi, chẳng hạn như danh sách.

Mặc dù các bộ dữ liệu có vẻ giống với danh sách, nhưng chúng thường được sử dụng trong các tình huống khác nhau và cho các mục đích khác nhau. Các bộ dữ liệu là bất biến và thường chứa một chuỗi các yếu tố không đồng nhất được truy cập thông qua việc giải nén (xem sau trong phần này) hoặc lập chỉ mục (hoặc thậm chí bởi thuộc tính trong trường hợp

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
8). Danh sách có thể thay đổi, và các yếu tố của chúng thường đồng nhất và được truy cập bằng cách lặp lại trong danh sách.immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
8). Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

Một vấn đề đặc biệt là việc xây dựng các bộ dữ liệu chứa 0 hoặc 1 mục: cú pháp có thêm một số quirks để phù hợp với những thứ này. Các bộ dữ liệu trống được xây dựng bởi một cặp dấu ngoặc đơn trống; Một tuple với một mục được xây dựng bằng cách làm theo giá trị bằng dấu phẩy (không đủ để gửi một giá trị duy nhất trong ngoặc đơn). Xấu xí, nhưng hiệu quả. Ví dụ:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
1

Tuyên bố

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
9 là một ví dụ về đóng gói tple: các giá trị
squares = list(map(lambda x: x**2, range(10)))
0,
squares = list(map(lambda x: x**2, range(10)))
1 và
squares = list(map(lambda x: x**2, range(10)))
2 được đóng gói với nhau trong một tuple. Hoạt động ngược cũng có thể:

Điều này được gọi, đủ thích hợp, giải nén trình tự và hoạt động cho bất kỳ chuỗi nào ở phía bên phải. Trình tự giải nén yêu cầu có nhiều biến ở phía bên trái của dấu bằng như có các phần tử trong chuỗi. Lưu ý rằng nhiều bài tập thực sự chỉ là sự kết hợp của việc đóng gói và giải nén trình tự.

5.4. ĐặtSets¶

Python cũng bao gồm một loại dữ liệu cho các bộ. Một bộ là một bộ sưu tập không có thứ tự không có yếu tố trùng lặp. Sử dụng cơ bản bao gồm kiểm tra thành viên và loại bỏ các mục trùng lặp. Đặt các đối tượng cũng hỗ trợ các hoạt động toán học như liên minh, giao lộ, sự khác biệt và sự khác biệt đối xứng.

Niềng răng xoăn hoặc hàm

squares = list(map(lambda x: x**2, range(10)))
3 có thể được sử dụng để tạo các bộ. Lưu ý: Để tạo một bộ trống, bạn phải sử dụng
squares = list(map(lambda x: x**2, range(10)))
3, không phải
squares = list(map(lambda x: x**2, range(10)))
5; Cái sau tạo ra một từ điển trống, một cấu trúc dữ liệu mà chúng ta thảo luận trong phần tiếp theo.

Đây là một cuộc biểu tình ngắn gọn:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
2

Tương tự như danh sách toàn diện, bộ toàn diện cũng được hỗ trợ:list comprehensions, set comprehensions are also supported:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
3

5.5. Từ điển bàiDictionaries¶

Một loại dữ liệu hữu ích khác được tích hợp vào Python là từ điển (xem các loại ánh xạ - dict). Từ điển đôi khi được tìm thấy trong các ngôn ngữ khác như là ký ức liên kết của người Hồi giáo hoặc các mảng liên kết của người Hồi giáo. Không giống như các chuỗi, được lập chỉ mục bởi một loạt các số, từ điển được lập chỉ mục bởi các khóa, có thể là bất kỳ loại bất biến; Chuỗi và số luôn có thể là chìa khóa. Bộ dữ liệu có thể được sử dụng làm khóa nếu chúng chỉ chứa chuỗi, số hoặc bộ dữ liệu; Nếu một tuple chứa bất kỳ đối tượng có thể thay đổi trực tiếp hoặc gián tiếp, nó không thể được sử dụng làm khóa. Bạn có thể sử dụng danh sách làm khóa làm khóa, vì danh sách có thể được sửa đổi tại chỗ bằng cách sử dụng các bài tập chỉ mục, bài tập lát cắt hoặc các phương thức như

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
7 và
squares = list(map(lambda x: x**2, range(10)))
7.Mapping Types — dict). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
7 and
squares = list(map(lambda x: x**2, range(10)))
7.

Tốt nhất là nghĩ về một từ điển như một tập hợp các khóa: các cặp giá trị, với yêu cầu rằng các khóa là duy nhất (trong một từ điển). Một cặp niềng răng tạo ra một từ điển trống:

squares = list(map(lambda x: x**2, range(10)))
5. Đặt một danh sách phân tách bằng dấu phẩy: các cặp giá trị trong niềng răng thêm khóa ban đầu: các cặp giá trị vào từ điển; Đây cũng là cách từ điển được viết trên đầu ra.

Các hoạt động chính trên từ điển đang lưu trữ một giá trị với một số khóa và trích xuất giá trị được đưa ra khóa. Cũng có thể xóa một cặp khóa: giá trị với

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1. Nếu bạn lưu trữ bằng cách sử dụng một khóa đã được sử dụng, giá trị cũ được liên kết với khóa đó sẽ bị lãng quên. Đó là một lỗi để trích xuất một giá trị bằng cách sử dụng khóa không tồn tại.

Thực hiện

squares = [x**2 for x in range(10)]
0 trên một từ điển trả về danh sách tất cả các khóa được sử dụng trong từ điển, theo thứ tự chèn (nếu bạn muốn nó được sắp xếp, chỉ cần sử dụng
squares = [x**2 for x in range(10)]
1 thay thế). Để kiểm tra xem một khóa duy nhất có trong từ điển hay không, hãy sử dụng từ khóa
squares = [x**2 for x in range(10)]
2.

Dưới đây là một ví dụ nhỏ bằng cách sử dụng từ điển:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
4

Trình xây dựng

squares = [x**2 for x in range(10)]
3 xây dựng từ điển trực tiếp từ các chuỗi của các cặp giá trị khóa:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
5

Ngoài ra, các toàn bộ Dict có thể được sử dụng để tạo từ điển từ các biểu thức chính và giá trị tùy ý:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
6

Khi các phím là các chuỗi đơn giản, đôi khi việc chỉ định các cặp bằng các đối số từ khóa sẽ dễ dàng hơn:

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
7

5.6. Kỹ thuật lặp lạiLooping Techniques¶

Khi lặp qua từ điển, khóa và giá trị tương ứng có thể được truy xuất cùng một lúc bằng phương pháp

squares = [x**2 for x in range(10)]
4.

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
8

Khi lặp qua một chuỗi, chỉ số vị trí và giá trị tương ứng có thể được truy xuất cùng một lúc bằng cách sử dụng hàm

squares = [x**2 for x in range(10)]
5.

def powersum(power, *args):
    #Return the sum of each argument raised to the specified power.
    total = 0
    for i in args:
        total += pow(i, power)
    return total

#function call
print(powersum(2, 3, 4))
9

Để lặp qua hai hoặc nhiều chuỗi cùng một lúc, các mục có thể được ghép nối với hàm

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
0

Để lặp qua một chuỗi ngược lại, trước tiên chỉ định chuỗi theo hướng chuyển tiếp và sau đó gọi hàm

squares = [x**2 for x in range(10)]
7.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
1

Để lặp qua một chuỗi theo thứ tự được sắp xếp, hãy sử dụng hàm

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
9 trả về một danh sách được sắp xếp mới trong khi để lại nguồn không thay đổi.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
2

Sử dụng

squares = list(map(lambda x: x**2, range(10)))
3 trên một chuỗi loại bỏ các yếu tố trùng lặp. Việc sử dụng
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
9 kết hợp với
squares = list(map(lambda x: x**2, range(10)))
3 qua một chuỗi là một cách thành ngữ để lặp qua các yếu tố duy nhất của chuỗi theo thứ tự được sắp xếp.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
3

Đôi khi thật hấp dẫn khi thay đổi một danh sách trong khi bạn đang lặp lại nó; Tuy nhiên, thay vào đó, nó thường đơn giản và an toàn hơn để tạo một danh sách mới.

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
4

5.7. Thêm về điều kiện lorMore on Conditions¶

Các điều kiện được sử dụng trong các câu lệnh

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
02 và
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
3 có thể chứa bất kỳ toán tử nào, không chỉ so sánh.

Các toán tử so sánh

squares = [x**2 for x in range(10)]
2 và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
05 là các thử nghiệm thành viên xác định xem một giá trị có ở (hoặc không) trong một thùng chứa hay không. Các toán tử
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
06 và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
07 so sánh xem hai đối tượng có thực sự là cùng một đối tượng hay không. Tất cả các toán tử so sánh có cùng mức độ ưu tiên, thấp hơn so với tất cả các toán tử số.

So sánh có thể được xích. Ví dụ,

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
08 kiểm tra xem
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
6 có nhỏ hơn
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
10 hay không và hơn nữa
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
10 bằng
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
12.

So sánh có thể được kết hợp bằng cách sử dụng các toán tử Boolean

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
13 và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
14, và kết quả của một so sánh (hoặc của bất kỳ biểu thức boolean nào khác) có thể bị phủ định với
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
15. Chúng có các ưu tiên thấp hơn các nhà khai thác so sánh; Giữa họ,
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
15 có ưu tiên cao nhất và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
14 thấp nhất, do đó
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
18 tương đương với
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
19. Như mọi khi, dấu ngoặc đơn có thể được sử dụng để thể hiện thành phần mong muốn.

Các toán tử Boolean

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
13 và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
14 là các toán tử được gọi là các toán tử ngắn mạch: đối số của họ được đánh giá từ trái sang phải và việc đánh giá dừng ngay khi kết quả được xác định. Ví dụ: nếu
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
22 và
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
23 là đúng nhưng
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
24 là sai,
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
25 không đánh giá biểu thức
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
23. Khi được sử dụng làm giá trị chung và không phải là boolean, giá trị trả về của toán tử ngắn mạch là đối số được đánh giá cuối cùng.

Có thể gán kết quả so sánh hoặc biểu thức boolean khác cho một biến. Ví dụ,

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
5

Lưu ý rằng trong Python, không giống như C, việc gán bên trong các biểu thức phải được thực hiện rõ ràng với toán tử Walrus

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
27. Điều này tránh được một nhóm vấn đề phổ biến gặp phải trong các chương trình C: gõ
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
28 vào biểu thức khi
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
29 được dự định.walrus operator
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
27. This avoids a common class of problems encountered in C programs: typing
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
28 in an expression when
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
29 was intended.

5,8. So sánh trình tự và các loại khácComparing Sequences and Other Types¶

Các đối tượng trình tự thường có thể được so sánh với các đối tượng khác có cùng loại trình tự. Việc so sánh sử dụng thứ tự từ vựng: đầu tiên hai mục đầu tiên được so sánh và nếu chúng khác nhau thì điều này sẽ xác định kết quả của so sánh; Nếu chúng bằng nhau, hai mục tiếp theo được so sánh, v.v., cho đến khi một trong hai chuỗi bị cạn kiệt. Nếu hai mục được so sánh là các chuỗi cùng loại, so sánh từ vựng được thực hiện đệ quy. Nếu tất cả các mục của hai chuỗi so sánh bằng nhau, các chuỗi được coi là bằng nhau. Nếu một chuỗi là một chuỗi con ban đầu của bảng khác, trình tự ngắn hơn là phần nhỏ hơn (nhỏ hơn). Đặt hàng từ vựng cho các chuỗi sử dụng số điểm mã Unicode để đặt hàng các ký tự riêng lẻ. Một số ví dụ về so sánh giữa các chuỗi cùng loại:

def func(myTuple):
    first, second = myTuple
    return first

#Driver Code
myTuple = (2,3)
#function call 1
print(func(myTuple))
#function call 2
print(func((2, 3)))
6

Lưu ý rằng việc so sánh các đối tượng thuộc các loại khác nhau với

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
30 hoặc
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
31 là hợp pháp với điều kiện là các đối tượng có các phương pháp so sánh phù hợp. Ví dụ, các loại số hỗn hợp được so sánh theo giá trị số của chúng, do đó 0 bằng 0,0, v.v. Nếu không, thay vì cung cấp một thứ tự tùy ý, trình thông dịch sẽ tăng ngoại lệ
a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
32.

Chú thích

1

Các ngôn ngữ khác có thể trả về đối tượng đột biến, cho phép chuỗi phương thức, chẳng hạn như

a, b = 1, 2
a, b = (1, 2)
(a, b) = 1, 2
33.