Hướng dẫn python array attributes - thuộc tính mảng python

Python như bạn có nghĩa là nó

Được trang bị sự hiểu biết của chúng tôi về các mảng numpy đa chiều, bây giờ chúng tôi xem xét các phương thức để lập trình kiểm tra một thuộc tính mảng (ví dụ: & nbsp; chiều của nó). Điều đặc biệt quan trọng là phải hiểu một mảng có hình dạng hình dạng là gì.

Chúng tôi sẽ sử dụng mảng sau đây để cung cấp bối cảnh cho cuộc thảo luận của chúng tôi:

>>> import numpy as np
>>> example_array = np.array([[[ 0,  1,  2,  3],
...                            [ 4,  5,  6,  7]],
...
...                           [[ 8,  9, 10, 11],
...                            [12, 13, 14, 15]],
...
...                           [[16, 17, 18, 19],
...                            [20, 21, 22, 23]]])

Theo cuộc thảo luận trước đó, nó là một mảng 3 chiều có cấu trúc sao cho:

  • Trục-0 phân biệt trong số 3 tờ để chọn.3 sheets to select from.

  • Axis-1 nhận ra trong số 2 hàng, trong bất kỳ bảng nào, để chọn từ.2 rows, in any sheet, to select from.

  • Trục-2 phân biệt trong số 4 cột, trong bất kỳ bảng và hàng nào, để chọn từ.4 columns, in any sheet and row, to select from.

ndarray.ndim::

Số lượng trục (kích thước) của mảng.

# dimensionality of the array
>>> example_array.ndim
3

ndarray.shape::

Một bộ số số nguyên cho biết số lượng các phần tử được lưu trữ dọc theo mỗi chiều của mảng. Đối với một mảng 2d với các hàng \ (n \) và các cột \ (m \), hình dạng sẽ là \ ((n, m) \). Do đó, độ dài của hình dạng hình này bằng số lượng kích thước của mảng.\(N\) rows and \(M\) columns, shape will be \((N, M)\). The length of this shape-tuple is therefore equal to the number of dimensions of the array.

# shape of the array
>>> example_array.shape
(3, 2, 4)

ndarray.size::

Tổng số phần tử của mảng. Điều này bằng với sản phẩm của các yếu tố của hình dạng mảng.

# size of the array: the number of elements it stores
>>> example_array.size
24

ndarray.dtype::

Một đối tượng mô tả kiểu dữ liệu của các phần tử trong mảng. Hãy nhớ lại rằng nd-marrays NUMPY là đồng nhất: họ chỉ có thể sở hữu số lượng loại dữ liệu thống nhất.

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')

ndarray.itemsize::

Kích thước, tính bằng byte (8 bit là 1 byte), của mỗi phần tử của mảng. Ví dụ: một mảng các phần tử thuộc loại

# size of the array: the number of elements it stores
>>> example_array.size
24
9 có mục này 8 \ ((= \ frac {64} {8}) \), trong khi một mảng loại
# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
0 có mục 4 \ ((= \ frac {32} {8} ) \).\((= \frac{64}{8})\), while an array of type
# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
0 has itemsize 4 \((= \frac{32}{8})\).

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4

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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
1.

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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
2.

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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
3 chèn ở phía trước danh sách và
# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
4 tương đương với
# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
5.

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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
6 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,

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
7 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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
8.

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

# `example_array` contains integers, each of which are stored using 32 bits of memory
>>> example_array.dtype
dtype('int32')
6 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

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
0 để 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

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
1.

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ư

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
2,
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
3 hoặc
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
4 chỉ sửa đổi danh sách không có giá trị trả về được in - chúng trả lại
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
5 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,

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
6 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ụ,
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
7 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

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
8. Để lấy một mục từ đầu ngăn xếp, hãy sử dụng
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
9 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

>>> 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 đượ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

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

# dimensionality of the array
>>> example_array.ndim
3
0

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

# dimensionality of the array
>>> example_array.ndim
3
1

đó 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 đề

>>> 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, sau đó không hoặc nhiều hơn
>>> 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 hoặc
>>> 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. 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
>>> 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 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'
4 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:

# dimensionality of the array
>>> example_array.ndim
3
2

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

# dimensionality of the array
>>> example_array.ndim
3
3

Lưu ý cách thứ tự của các câu lệ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'
2 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'
4 giống nhau trong cả hai đoạn này.

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

>>> 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 trong ví dụ trước), nó phải được đặt dấu ngoặc đơn.

# dimensionality of the array
>>> example_array.ndim
3
4

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:

# dimensionality of the array
>>> example_array.ndim
3
5

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:

# dimensionality of the array
>>> example_array.ndim
3
6

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

# dimensionality of the array
>>> example_array.ndim
3
7

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

>>> 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 theo sau, vì vậy ví dụ này tương đương với:

# dimensionality of the array
>>> example_array.ndim
3
8

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

# dimensionality of the array
>>> example_array.ndim
3
9

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

>>> 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 sẽ làm rất tốt cho trường hợp sử dụng này:

# shape of the array
>>> example_array.shape
(3, 2, 4)
0

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ố >>> 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] 2The >>> 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 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

>>> 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. Điều này khác với phương thức
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
9 trả về giá trị. Câu lệ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]
2 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ụ:

# shape of the array
>>> example_array.shape
(3, 2, 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 cũng có thể được sử dụng để xóa toàn bộ biến:

Tham khảo tê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]
7 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
>>> 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 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ụ:

# shape of the array
>>> example_array.shape
(3, 2, 4)
2

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

>>> 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). 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
>>> 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). 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ụ:

# shape of the array
>>> example_array.shape
(3, 2, 4)
3

Tuyên bố

>>> 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 là một ví dụ về đóng gói tple: các giá trị
>>> 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,
>>> 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'])
2 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 đó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

>>> 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'])
4 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
>>> 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'])
4, không phải
>>> 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'])
6; 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:

# shape of the array
>>> example_array.shape
(3, 2, 4)
4

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:

# shape of the array
>>> example_array.shape
(3, 2, 4)
5

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ư

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
8 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'])
8.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
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
8 and
>>> 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.

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:

>>> 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'])
6. Đặ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

>>> 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. 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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1 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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
2 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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
3.

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

# shape of the array
>>> example_array.shape
(3, 2, 4)
6

Trình xây dựng

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

# shape of the array
>>> example_array.shape
(3, 2, 4)
7

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

# shape of the array
>>> example_array.shape
(3, 2, 4)
8

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:

# shape of the array
>>> example_array.shape
(3, 2, 4)
9

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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
5.

# size of the array: the number of elements it stores
>>> example_array.size
24
0

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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
6.

# size of the array: the number of elements it stores
>>> example_array.size
24
1

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

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

# size of the array: the number of elements it stores
>>> example_array.size
24
2

Để 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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
8.

# size of the array: the number of elements it stores
>>> example_array.size
24
3

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

# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
0 trả về một danh sách được sắp xếp mới trong khi để lại nguồn không thay đổi.

# size of the array: the number of elements it stores
>>> example_array.size
24
4

Sử dụng

>>> 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'])
4 trên một chuỗi loại bỏ các yếu tố trùng lặp. Việc sử dụng
# each integer in `example_array` is represented using 4 bytes (32 bits) of memory
>>> example_array.itemsize
4
0 kết hợp với
>>> 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'])
4 qua một chuỗi là một cách thành ngữ để lặp lại các yếu tố duy nhất của chuỗi theo thứ tự được sắp xếp.

# size of the array: the number of elements it stores
>>> example_array.size
24
5

Đô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.

# size of the array: the number of elements it stores
>>> example_array.size
24
6

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

# dimensionality of the array
>>> example_array.ndim
3
03 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'
4 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 = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
3 và
# dimensionality of the array
>>> example_array.ndim
3
06 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ử
# dimensionality of the array
>>> example_array.ndim
3
07 và
# dimensionality of the array
>>> example_array.ndim
3
08 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ụ,

# dimensionality of the array
>>> example_array.ndim
3
09 kiểm tra xem
>>> 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 có nhỏ hơn
# dimensionality of the array
>>> example_array.ndim
3
11 và hơn nữa
# dimensionality of the array
>>> example_array.ndim
3
11 bằng
# dimensionality of the array
>>> example_array.ndim
3
13.

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

# dimensionality of the array
>>> example_array.ndim
3
14 và
# dimensionality of the array
>>> example_array.ndim
3
15, 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
# dimensionality of the array
>>> example_array.ndim
3
16. Chúng có các ưu tiên thấp hơn các nhà khai thác so sánh; Giữa họ,
# dimensionality of the array
>>> example_array.ndim
3
16 có mức ưu tiên cao nhất và
# dimensionality of the array
>>> example_array.ndim
3
15 thấp nhất, do đó
# dimensionality of the array
>>> example_array.ndim
3
19 tương đương với
# dimensionality of the array
>>> example_array.ndim
3
20. 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

# dimensionality of the array
>>> example_array.ndim
3
14 và
# dimensionality of the array
>>> example_array.ndim
3
15 được gọi là 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
# dimensionality of the array
>>> example_array.ndim
3
23 và
# dimensionality of the array
>>> example_array.ndim
3
24 là đúng nhưng
# dimensionality of the array
>>> example_array.ndim
3
25 là sai,
# dimensionality of the array
>>> example_array.ndim
3
26 không đánh giá biểu thức
# dimensionality of the array
>>> example_array.ndim
3
24. 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ụ,

# size of the array: the number of elements it stores
>>> example_array.size
24
7

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

# dimensionality of the array
>>> example_array.ndim
3
28. Đ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õ
# dimensionality of the array
>>> example_array.ndim
3
29 vào một biểu thức khi dự định
# dimensionality of the array
>>> example_array.ndim
3
30.walrus operator
# dimensionality of the array
>>> example_array.ndim
3
28. This avoids a common class of problems encountered in C programs: typing
# dimensionality of the array
>>> example_array.ndim
3
29 in an expression when
# dimensionality of the array
>>> example_array.ndim
3
30 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:

# size of the array: the number of elements it stores
>>> example_array.size
24
8

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

# dimensionality of the array
>>> example_array.ndim
3
31 hoặc
# dimensionality of the array
>>> example_array.ndim
3
32 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ệ
# dimensionality of the array
>>> example_array.ndim
3
33.

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ư

# dimensionality of the array
>>> example_array.ndim
3
34.