Các hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 tích hợp của Python có ích khi bạn cần tìm các giá trị nhỏ nhất và lớn nhất trong một cuộc tranh luận thông thường hoặc trong một loạt các đối số thông thường. Mặc dù những điều này có vẻ giống như các tính toán khá cơ bản, chúng hóa ra có nhiều trường hợp sử dụng thú vị trong lập trình trong thế giới thực. Bạn sẽ thử một số trường hợp sử dụng ở đây.smallest and largest values in an iterable or in a series of regular arguments. Even though these might seem like fairly basic computations, they turn out to have many interesting use cases in real-world programing. You’ll try out some of those use cases here.Trong hướng dẫn này, bạn sẽ học cách:
- Sử dụng Python từ
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạnsmallest and largest values in your datamin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Gọi
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với một lần lặp lại hoặc với bất kỳ số lượng đối số thông thường nàoiterable or with any number of regular argumentsmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Sử dụng
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và từ điểnstrings and dictionariesmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Điều chỉnh hành vi của
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với các đối sốmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
4>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
3 and>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
4 arguments>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
- Sử dụng các biểu thức toàn diện và trình tạo làm đối số cho
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4comprehensions and generator expressions as arguments tomin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 andmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Khi bạn có kiến thức này trong vành đai của mình, thì bạn sẽ sẵn sàng viết một loạt các ví dụ thực tế sẽ thể hiện tính hữu ích của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Cuối cùng, bạn sẽ mã hóa các phiên bản min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 của riêng mình trong Python Pure Python, điều này có thể giúp bạn hiểu cách các chức năng này hoạt động trong nội bộ.Để tận dụng tối đa hướng dẫn này, bạn nên có một số kiến thức trước đây về lập trình Python, bao gồm các chủ đề như
>>> min["abcdefghijklmnopqrstuvwxyz"]
'a'
>>> max["abcdefghijklmnopqrstuvwxyz"]
'z'
>>> min["abcdWXYZ"]
'W'
>>> max["abcdWXYZ"]
'd'
1 vòng lặp, chức năng, danh sách toàn diện và biểu thức máy phát.Bắt đầu với các chức năng Python từ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Python bao gồm một số chức năng tích hợp làm cho cuộc sống của bạn dễ chịu và hiệu quả hơn vì chúng có nghĩa là bạn không cần phải phát minh lại bánh xe. Hai ví dụ về các chức năng này là
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Chúng chủ yếu áp dụng cho các vòng lặp, nhưng bạn cũng có thể sử dụng chúng với nhiều đối số thông thường. Công việc của họ là gì? Họ quan tâm đến việc tìm kiếm các giá trị nhỏ nhất và lớn nhất trong dữ liệu đầu vào của họ.Cho dù bạn sử dụng Python từ
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, bạn có thể sử dụng chức năng để đạt được hai hành vi hơi khác nhau. Hành vi tiêu chuẩn cho mỗi hành vi là trả về giá trị tối thiểu hoặc tối đa thông qua so sánh đơn giản của dữ liệu đầu vào khi nó đứng. Hành vi thay thế là sử dụng chức năng đơn lẻ để sửa đổi các tiêu chí so sánh trước khi tìm các giá trị nhỏ nhất và lớn nhất.Để khám phá hành vi tiêu chuẩn của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, bạn có thể bắt đầu bằng cách gọi mỗi hàm với một hàm có thể lặp lại như một đối số hoặc với hai hoặc nhiều đối số thông thường. Đó là những gì bạn sẽ làm ngay lập tức.Gọi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với một đối số có thể lặp lại
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 tích hợp có hai chữ ký khác nhau cho phép bạn gọi chúng bằng một điều có thể được lặp lại như đối số đầu tiên của họ hoặc với hai hoặc nhiều đối số thông thường. Chữ ký chấp nhận một đối số có thể lặp lại duy nhất trông giống như sau:min[iterable, *[, default, key]] -> minimum_value
max[iterable, *[, default, key]] -> maximum_value
Cả hai hàm đều có một đối số yêu cầu gọi là
>>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4 và trả về các giá trị tối thiểu và tối đa tương ứng. Họ cũng lấy hai đối số chỉ từ khóa tùy chọn: >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3.Ở đây, một bản tóm tắt về những gì các đối số cho
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 làm:
4 | Lấy một đối tượng có thể đi được, như một danh sách, tuple, từ điển hoặc chuỗi | Đúng |
4 | Giữ một giá trị để trả về nếu có thể đầu vào có thể trống | Không |
3 | Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh | Không |
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trong Python:>>>
Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trong Python:>>>
Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trong Python:Gọi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với nhiều đối số
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Chữ ký thứ hai của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 cho phép bạn gọi cho họ với bất kỳ số lượng đối số nào, miễn là bạn sử dụng ít nhất hai đối số. Chữ ký này có hình thức sau:min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Một lần nữa, các hàm này trả về các giá trị tối thiểu và tối đa, tương ứng. Ở đây, ý nghĩa của các đối số trong chữ ký trên:
09 | Chấp nhận bất kỳ số lượng đối số thông thường để so sánh | Có [ít nhất hai trong số họ] |
3 | Mất chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh | Không |
Biến thể này của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 không có đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4. Bạn phải cung cấp ít nhất hai đối số trong cuộc gọi cho chức năng hoạt động chính xác. Vì vậy, giá trị >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 không cần thiết, bởi vì bạn sẽ luôn có ít nhất hai giá trị để so sánh để tìm mức tối thiểu hoặc tối đa.Để thử chữ ký thay thế này, hãy chạy các ví dụ sau:
>>>
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và vòng lặp của chuỗi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Theo mặc định,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có thể xử lý các giá trị có thể so sánh. Nếu không, bạn nhận được một >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04, như bạn đã học. Cho đến thời điểm này, bạn đã thấy các ví dụ sử dụng các giá trị số trong một đối số có thể lặp lại hoặc nhiều đối số thông thường.Sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với các giá trị số được cho là trường hợp sử dụng phổ biến và hữu ích nhất của các hàm này. Tuy nhiên, bạn cũng có thể sử dụng các chức năng với chuỗi và vòng lặp của chuỗi. Trong những trường hợp này, thứ tự bảng chữ cái của các ký tự sẽ quyết định kết quả cuối cùng.Ví dụ: bạn có thể sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 để tìm các chữ cái nhỏ nhất và lớn nhất trong một số văn bản. Trong bối cảnh này, nhỏ nhất có nghĩa là gần nhất với đầu bảng chữ cái và lớn nhất có nghĩa là gần nhất với phần cuối của bảng chữ cái:>>>
>>> min["abcdefghijklmnopqrstuvwxyz"]
'a'
>>> max["abcdefghijklmnopqrstuvwxyz"]
'z'
>>> min["abcdWXYZ"]
'W'
>>> max["abcdWXYZ"]
'd'
Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và vòng lặp của chuỗiTheo mặc định,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có thể xử lý các giá trị có thể so sánh. Nếu không, bạn nhận được một >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04, như bạn đã học. Cho đến thời điểm này, bạn đã thấy các ví dụ sử dụng các giá trị số trong một đối số có thể lặp lại hoặc nhiều đối số thông thường.>>>
>>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.>>>
>>> ord["A"]
65
>>> ord["a"]
97
Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Unicode code point of that character. In these examples, the code point for the uppercase >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
43 is lower than the code point for the lowercase >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44.Sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và vòng lặp của chuỗi>>>
>>> min["aA"]
'A'
>>> max["aA"]
'a'
Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và vòng lặp của chuỗi
>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
0Bạn có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và vòng lặp của chuỗiLưu ý rằng có hai từ bắt đầu bằng
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
58, >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
63 và >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
64. Vì vậy, Python tiến hành nhìn vào chữ cái thứ hai của mỗi từ. Kết quả là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
64 vì >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
67 xuất hiện sau >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
68.Xử lý từ điển với min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Khi nói đến việc xử lý từ điển Python với
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, bạn cần xem xét rằng nếu bạn sử dụng trực tiếp từ điển, thì cả hai chức năng sẽ hoạt động trên các khóa:>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
1Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
2Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.
>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
3Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.
>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
4Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.
Một yêu cầu phổ biến khác sẽ là tìm các giá trị nhỏ nhất và lớn nhất trong từ điển. Để tiếp tục với ví dụ
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74, giả sử bạn muốn biết giá nhỏ nhất và lớn nhất. Trong tình huống này, bạn có thể sử dụng phương pháp >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
78:Trong các ví dụ này, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 đi qua tất cả các giá trị trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và tìm thấy giá tối thiểu. Tương tự, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 lặp lại các giá trị của >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và trả về giá tối đa.
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
Cuối cùng, bạn cũng có thể sử dụng phương thức
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
83 trên từ điển đầu vào để tìm các cặp giá trị khóa tối thiểu và tối đa:keyword-only arguments.Trong trường hợp này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 sử dụng các quy tắc nội bộ của Python, để so sánh các bộ dữ liệu và tìm các mục nhỏ nhất và lớn nhất trong từ điển đầu vào.Python so sánh mục của bộ dữ liệu từng mục. Ví dụ, để xác định xem
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
86 có lớn hơn >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
87], các thử nghiệm Python >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
88. Nếu điều kiện này là >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
89, thì Python kết luận rằng bộ thứ nhất lớn hơn lần thứ hai mà không kiểm tra phần còn lại của các mục. Ngược lại, nếu >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
90, thì Python kết luận rằng tuple thứ nhất nhỏ hơn lần thứ hai.>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
5Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.
>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
6Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:function object, or more accurately, a callable object.Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.
Một yêu cầu phổ biến khác sẽ là tìm các giá trị nhỏ nhất và lớn nhất trong từ điển. Để tiếp tục với ví dụ
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74, giả sử bạn muốn biết giá nhỏ nhất và lớn nhất. Trong tình huống này, bạn có thể sử dụng phương pháp >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
78:>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
7Trong các ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
74 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
76 trên từ điển đầu vào của mình:Sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với các biểu thức toàn diện và trình tạo
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Bạn cũng có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với danh sách hiểu hoặc biểu thức trình tạo làm đối số. Tính năng này có ích khi bạn cần chuyển đổi dữ liệu đầu vào ngay trước khi tìm giá trị biến đổi tối thiểu hoặc tối đa.list comprehension or generator expression as an argument. This feature comes in handy when you need to transform the input
data right before finding the minimum or maximum transformed value.Khi bạn cung cấp danh sách hiểu biết vào
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, giá trị kết quả sẽ đến từ dữ liệu được chuyển đổi thay vì từ dữ liệu gốc:>>>
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
8Cuộc gọi thứ hai đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
31 bằng cách áp dụng phương thức >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Lưu ý rằng sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, kết quả đến từ dữ liệu gốc:>>>
Cuộc gọi thứ hai đếnmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
31 bằng cách áp dụng phương thức >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Lưu ý rằng sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, kết quả đến từ dữ liệu gốc:
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
9generator expression instead.Trong cả hai ví dụ,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sử dụng >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
0Cuộc gọi thứ hai đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
31 bằng cách áp dụng phương thức >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Lưu ý rằng sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, kết quả đến từ dữ liệu gốc:
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
9Trong cả hai ví dụ,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sử dụng >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.Danh sách toàn diện tạo ra một danh sách đầy đủ trong bộ nhớ, thường là một hoạt động lãng phí. Thực tế này đặc biệt đúng nếu bạn không cần danh sách kết quả trong mã của bạn nữa, đây có thể là trường hợp với min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Vì vậy, nó luôn luôn hiệu quả hơn để sử dụng biểu thức máy phát.
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Cú pháp cho các biểu thức máy phát gần giống như đối với các toàn bộ danh sách:
>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
1Cuộc gọi thứ hai đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
31 bằng cách áp dụng phương thức >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Lưu ý rằng sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, kết quả đến từ dữ liệu gốc:
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
9>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
2Cuộc gọi thứ hai đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
31 bằng cách áp dụng phương thức >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Lưu ý rằng sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, kết quả đến từ dữ liệu gốc: >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
9
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
Trong cả hai ví dụ,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sử dụng >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.Chờ đợi! Tại sao
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3? Bạn có thể đối phó với các giá trị lớn, có phải bạn không? Vấn đề là bạn cần so sánh từng giá trị lớn với giới hạn trên của khoảng thời gian và sau đó chọn số nhỏ hơn của cả hai. Về cơ bản, bạn sẽ đặt tất cả các giá trị lớn thành giới hạn trên được quy định:>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
3Cuộc gọi đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
71 và >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
72 được cắt thành >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
73, đó là giới hạn trên của khoảng thời gian.Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, như trong ví dụ sau:>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
4Cuộc gọi đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
71 và >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
72 được cắt thành >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
73, đó là giới hạn trên của khoảng thời gian.Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, như trong ví dụ sau:>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
5Cuộc gọi đến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
71 và >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
72 được cắt thành >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
73, đó là giới hạn trên của khoảng thời gian.Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, như trong ví dụ sau:Cuộc gọi này đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 clip các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian. Để thực hiện việc cắt này, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 so sánh số hiện tại và giới hạn khoảng thời gian để tìm giá trị tối đa. Trong ví dụ, >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
77 là số duy nhất được cắt.
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
Cuối cùng, bạn có thể chạy cả hai thao tác trong một lần bằng cách kết hợp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Đây là cách làm điều đó:>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
6Để cắt tất cả các giá trị nằm ngoài giới hạn khoảng thời gian, sự hiểu biết này kết hợp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Cuộc gọi đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 so sánh giá trị hiện tại với giới hạn trên của khoảng thời gian, trong khi cuộc gọi đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 so sánh kết quả với giới hạn thấp hơn. Kết quả cuối cùng là các giá trị thấp hơn hoặc lớn hơn giới hạn tương ứng được cắt theo giới hạn.Sự hiểu biết này hoạt động tương tự như hàm
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
84 từ Numpy, có một mảng và giới hạn của khoảng mục tiêu, sau đó nó cắt tất cả các giá trị ngoài khoảng vào các cạnh của khoảng thời gian.Tìm những điểm gần nhất
Bây giờ nói rằng bạn có một danh sách các bộ dữ liệu chứa các cặp giá trị đại diện cho các điểm Cartesian. Bạn muốn xử lý tất cả các cặp điểm này và tìm ra cặp nào có khoảng cách nhỏ nhất giữa các điểm. Trong tình huống này, bạn có thể làm một cái gì đó như sau:
Trong ví dụ này, trước tiên bạn nhập
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
85 để có quyền truy cập vào >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
86. Hàm này trả về khoảng cách Euclide giữa hai điểm, p và q, mỗi điểm được đưa ra dưới dạng một chuỗi tọa độ. Hai điểm phải có cùng số lượng kích thước.>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
7Hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoạt động phép thuật của nó thông qua đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 của nó. Trong ví dụ này, >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 có hàm >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
90 tính khoảng cách giữa hai điểm. Hàm này trở thành tiêu chí so sánh cho min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 để tìm cặp điểm với khoảng cách tối thiểu giữa các điểm.Trong ví dụ này, bạn cần một hàm >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
90 vì >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 mong đợi một chức năng đối số đơn, trong khi >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
94 yêu cầu hai đối số. Vì vậy, hàm >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
90 có một đối số duy nhất, >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
96 và sau đó giải nén nó thành hai đối số để đưa vào >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
94.
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
Xác định các sản phẩm giá rẻ và đắt tiền
Bây giờ nói rằng bạn có một từ điển với tên và giá của một số sản phẩm và bạn muốn xác định các sản phẩm rẻ nhất và đắt nhất. Trong tình huống này, bạn có thể sử dụng
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
83 và hàm >>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
90 thích hợp như đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3:predicate function like the following:>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
8Trong ví dụ này, hàm
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
90 lấy một cặp giá trị khóa làm đối số và trả về giá trị tương ứng để min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có tiêu chí so sánh thích hợp. Do đó, bạn có được một bộ phận với các sản phẩm rẻ nhất và đắt nhất trong dữ liệu đầu vào.Tìm số số nguyên coprime
Một ví dụ thú vị khác về việc sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 để giải quyết vấn đề trong thế giới thực là khi bạn cần tìm ra nếu hai số là coprime. Nói cách khác, bạn cần biết liệu số của bạn có chỉ là người chia cấp thông thường là >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
05 hay không.
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
Trong tình huống đó, bạn có thể mã hóa một hàm giá trị boolean hoặc định vị như sau:
>>>
>>> min[[3, 5.0, 9, 1.0, -5]]
-5
>>> max[[3, 5.0, 9, 1.0, -5]]
9
9Cuộc gọi đến
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
15 chạy một câu lệnh dựa trên chuỗi một số lần nhất định. Trong các ví dụ này, tuyên bố được lặp lại ba lần. Cuộc gọi đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả về thời gian thực hiện nhỏ nhất từ ba lần lặp lại.Bằng cách kết hợp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3, >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
21 và các hàm hẹn giờ Python khác, bạn có thể có ý tưởng về thuật toán nào của bạn là hiệu quả nhất về thời gian thực hiện. Ví dụ trên cho thấy rằng các toàn bộ danh sách có thể nhanh hơn một chút so với hàm >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
22 tích hợp khi nói đến việc xây dựng các danh sách mới.Khám phá vai trò của >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24 trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Như bạn đã học được cho đến nay, các hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 tích hợp đủ để hoạt động với các giá trị của các loại dữ liệu khác nhau, chẳng hạn như số và chuỗi. Bí mật đằng sau tính linh hoạt này là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 ôm lấy triết lý đánh máy con vịt Python bằng cách dựa vào các phương pháp đặc biệt >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24.Những phương pháp này là một phần của những gì Python gọi là các phương pháp so sánh phong phú. Cụ thể,
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24 hỗ trợ các toán tử nhỏ hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35] và lớn hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36], tương ứng. Ý nghĩa của sự hỗ trợ ở đây là gì? Khi Python tìm thấy một cái gì đó như >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
37 trong mã của bạn, nó sẽ làm >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
38.rich comparison methods. Specifically, >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 and >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24 support the less than
[>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35] and greater than [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36] operators, respectively. What’s the meaning of support here? When Python finds something like >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
37 in your code, it internally does >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
38.Takeaway là bạn có thể sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với các giá trị của bất kỳ loại dữ liệu nào thực hiện >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24. Đó là lý do tại sao các chức năng này hoạt động với các giá trị của tất cả các loại dữ liệu tích hợp của Python,:>>>
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
0Các loại dữ liệu tích hợp Python, thực hiện các phương pháp đặc biệt
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24. Vì vậy, bạn có thể cung cấp bất kỳ loại dữ liệu nào trong số này vào min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, với điều kiện duy nhất là các loại dữ liệu liên quan có thể so sánh.Bạn cũng có thể thực hiện các phiên bản của các lớp tùy chỉnh của mình tương thích với
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Để đạt được điều này, bạn cần cung cấp các triển khai của riêng bạn >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24. Xem xét lớp >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
51 sau đây là một ví dụ về khả năng tương thích này:
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
1Lưu ý rằng việc triển khai
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24 yêu cầu một đối số mà thường có tên là >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
54. Đối số này đại diện cho toán hạng thứ hai trong các hoạt động so sánh cơ bản. Ví dụ: trong một biểu thức như >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
37, bạn sẽ có >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
56 sẽ là >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
57 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
58 sẽ là >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
54.Trong ví dụ này,
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24 trả về kết quả của việc so sánh hai người ____ ____362. Ở đây, cách thức hoạt động của nó trong thực tế:>>>
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
2Mát mẻ! Bạn có thể xử lý các đối tượng
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
51 với min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 vì lớp cung cấp triển khai >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24. Lời kêu gọi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 trả lại người trẻ nhất và cuộc gọi đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả lại người già nhất.Lưu ý rằng nếu một lớp tùy chỉnh đã cho không cung cấp các phương pháp này, thì các trường hợp của nó đã giành được hỗ trợ
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4:>>>
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
3Bởi vì lớp
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
72 này không cung cấp các triển khai phù hợp của >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
23 và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
24, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả lời với >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04. Thông báo lỗi cho bạn biết rằng các hoạt động so sánh được hỗ trợ trong lớp hiện tại của bạn.Mô phỏng Python từ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Cho đến thời điểm này, bạn đã học được cách hoạt động của Python từ ____43 và ____44. Bạn đã sử dụng chúng để tìm các giá trị nhỏ nhất và lớn nhất trong số một số số, chuỗi và hơn thế nữa. Bạn biết cách gọi các chức năng này với một điều duy nhất là một đối số hoặc với một số lượng đối số thông thường không xác định. Cuối cùng, bạn đã mã hóa một loạt các ví dụ thực tế tiếp cận các vấn đề trong thế giới thực bằng cách sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4.Mặc dù Python vui lòng cung cấp cho bạn
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạn, việc học cách thực hiện tính toán này từ đầu là một bài tập hữu ích có thể cải thiện tư duy logic và kỹ năng lập trình của bạn.Trong phần này, bạn sẽ học cách tìm các giá trị tối thiểu và tối đa trong dữ liệu của bạn. Bạn cũng sẽ học cách thực hiện các phiên bản
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 của riêng bạn.Hiểu mã đằng sau min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Để tìm giá trị tối thiểu trong một danh sách nhỏ các số với tư cách là con người, bạn thường kiểm tra các số và ngầm so sánh tất cả chúng trong tâm trí bạn. Vâng, bộ não của bạn thật tuyệt vời! Tuy nhiên, máy tính không thông minh. Họ cần hướng dẫn chi tiết để hoàn thành bất kỳ nhiệm vụ.
Bạn phải nói với máy tính của mình để lặp lại tất cả các giá trị trong khi so sánh chúng theo cặp. Trong quá trình, máy tính phải lưu ý đến giá trị tối thiểu hiện tại trong mỗi cặp cho đến khi danh sách các giá trị được xử lý hoàn toàn.
Giải thích này có thể khó hình dung, vì vậy, đây là một chức năng Python thực hiện công việc:
>>>
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
4Trong đoạn mã này, bạn xác định
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90. Hàm này giả định rằng >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4 không phải là trống và các giá trị của nó theo thứ tự tùy ý.Hàm coi giá trị đầu tiên là một
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 dự kiến. Sau đó, vòng lặp >>> min["abcdefghijklmnopqrstuvwxyz"]
'a'
>>> max["abcdefghijklmnopqrstuvwxyz"]
'z'
>>> min["abcdWXYZ"]
'W'
>>> max["abcdWXYZ"]
'd'
1 lặp lại phần còn lại của các phần tử trong dữ liệu đầu vào.Tuyên bố có điều kiện so sánh
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại với >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 dự kiến trong lần lặp đầu tiên. Nếu >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại nhỏ hơn >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92, thì các bản cập nhật có điều kiện >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 phù hợp.Mỗi lần lặp mới so sánh
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại với >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 được cập nhật. Khi hàm đạt đến cuối >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4, >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 sẽ giữ giá trị nhỏ nhất trong dữ liệu đầu vào.Mát mẻ! Bạn đã mã hóa một hàm tìm thấy giá trị nhỏ nhất trong số lượng số lượng. Bây giờ xem lại
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90 và nghĩ về cách bạn mã hóa một hàm để tìm giá trị lớn nhất. Vâng, đó là nó! Bạn chỉ cần thay đổi toán tử so sánh từ nhỏ hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35] thành lớn hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36] và có thể đổi tên hàm và một số biến cục bộ để ngăn chặn sự nhầm lẫn.Chức năng mới của bạn có thể trông giống như thế này:
>>>
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
5Trong đoạn mã này, bạn xác định
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90. Hàm này giả định rằng >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4 không phải là trống và các giá trị của nó theo thứ tự tùy ý.Hàm coi giá trị đầu tiên là một
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 dự kiến. Sau đó, vòng lặp >>> min["abcdefghijklmnopqrstuvwxyz"]
'a'
>>> max["abcdefghijklmnopqrstuvwxyz"]
'z'
>>> min["abcdWXYZ"]
'W'
>>> max["abcdWXYZ"]
'd'
1 lặp lại phần còn lại của các phần tử trong dữ liệu đầu vào.Tuyên bố có điều kiện so sánh
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại với >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 dự kiến trong lần lặp đầu tiên. Nếu >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại nhỏ hơn >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92, thì các bản cập nhật có điều kiện >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 phù hợp.Mỗi lần lặp mới so sánh
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
94 hiện tại với >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 được cập nhật. Khi hàm đạt đến cuối >>> # UTF-8 characters
>>> min["abc123ñ"]
'1'
>>> max["abc123ñ"]
'ñ'
4, >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
92 sẽ giữ giá trị nhỏ nhất trong dữ liệu đầu vào.
Mát mẻ! Bạn đã mã hóa một hàm tìm thấy giá trị nhỏ nhất trong số lượng số lượng. Bây giờ xem lại >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90 và nghĩ về cách bạn mã hóa một hàm để tìm giá trị lớn nhất. Vâng, đó là nó! Bạn chỉ cần thay đổi toán tử so sánh từ nhỏ hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35] thành lớn hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36] và có thể đổi tên hàm và một số biến cục bộ để ngăn chặn sự nhầm lẫn.
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
Chức năng mới của bạn có thể trông giống như thế này:
Lưu ý rằng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
06 chia sẻ hầu hết mã của nó với >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90. Sự khác biệt quan trọng nhất, ngoài việc đặt tên, là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
06 sử dụng toán tử lớn hơn toán tử [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36] thay vì ít hơn toán tử [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35].>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
6Là một bài tập, bạn có thể nghĩ cách tránh mã lặp đi lặp lại trong nguyên tắc
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
90 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
06 tuân theo nguyên tắc khô [don Lặp lại]. Bằng cách này, bạn sẽ sẵn sàng mô phỏng hành vi hoàn chỉnh của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 bằng cách sử dụng các kỹ năng Python của bạn, mà bạn sẽ giải quyết chỉ trong giây lát.
Để viết các triển khai tùy chỉnh của bạn là 3 và 4, bạn sẽ bắt đầu bằng cách mã hóa một hàm trợ giúp mà có thể tìm thấy giá trị nhỏ nhất hoặc lớn nhất trong dữ liệu đầu vào, tùy thuộc vào các đối số bạn sử dụng trong cuộc gọi. Tất nhiên, hàm trợ giúp sẽ đặc biệt phụ thuộc vào toán tử được sử dụng để so sánh các giá trị đầu vào. | Chức năng trợ giúp của bạn sẽ có chữ ký sau: | Ở đây, những gì mỗi đối số làm: |
Tranh luận | Sự mô tả | Ở đây, những gì mỗi đối số làm: |
Tranh luận | Sự mô tả | Yêu cầu |
16 | Cho phép bạn gọi chức năng với một số lượng khác hoặc bất kỳ số lượng đối số thông thường | Yêu cầu |
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
16Cho phép bạn gọi chức năng với một số lượng khác hoặc bất kỳ số lượng đối số thông thường
Đúngoperator functions to find the minimum and maximum values, respectively. You’ll learn more about operator functions in a moment.
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Giữ chức năng toán tử so sánh thích hợp để tính toán trong tay
>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
7>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3Có chức năng đơn lẻ để sửa đổi chức năng so sánh tiêu chí và hành vi
Nếu
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
38 tăng >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04, thì bạn sẽ bắt nó và tự nâng >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04 của riêng bạn để thông báo cho người dùng rằng đối tượng được cung cấp không thể hiểu được, giống như min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 làm ở dạng tiêu chuẩn của họ. Lưu ý rằng bạn sử dụng cú pháp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
44 để ẩn đi dấu vết của >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04 ban đầu.Chi nhánh
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
46 chạy khi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
35 chứa nhiều hơn một giá trị, xử lý các trường hợp người dùng gọi hàm với một số đối số thông thường thay vì với một giá trị có thể lặp lại.Nếu điều kiện này cuối cùng không tăng
>>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04, thì min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49 sẽ giữ một danh sách các giá trị có thể trống. Ngay cả khi danh sách kết quả trống rỗng, thì giờ đây, nó đã sạch sẽ và sẵn sàng để tiếp tục quá trình tìm kiếm giá trị tối thiểu hoặc tối đa của nó.Xử lý đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
Để tiếp tục viết
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25, bây giờ bạn có thể xử lý đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4. Đi trước và thêm mã sau vào cuối hàm:>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
8Trong đoạn mã này, bạn xác định một điều kiện để kiểm tra xem
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49 có giữ một danh sách trống không. Nếu trường hợp đó, thì bạn sẽ kiểm tra đối số >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 để xem người dùng có cung cấp giá trị cho nó không. Nếu >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 vẫn là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
56, thì >>> min["aA"]
'A'
>>> max["aA"]
'a'
5 được nâng lên. Nếu không, >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 được trả lại. Hành vi này mô phỏng hành vi tiêu chuẩn của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 khi bạn gọi chúng bằng các vòng lặp trống.Xử lý chức năng >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 tùy chọn
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
Bây giờ bạn cần xử lý đối số
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 và chuẩn bị dữ liệu để tìm các giá trị nhỏ nhất và lớn nhất theo >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 được cung cấp. Đi trước và cập nhật min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 với mã sau:>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
9Bạn bắt đầu đoạn mã này với một điều kiện kiểm tra xem người dùng đã cung cấp chức năng
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3. Nếu họ trú ẩn, thì bạn sẽ tạo một danh sách các khóa trực tiếp từ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49 ban đầu của bạn. Bạn sẽ sử dụng các khóa này làm khóa so sánh trong việc tính toán mức tối thiểu và tối đa.Mặt khác, nếu người dùng đã cung cấp đối số
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3, thì bạn cần đảm bảo rằng đối số thực sự là một hàm hoặc đối tượng có thể gọi được. Để làm điều này, bạn sử dụng hàm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
68 tích hợp, trả về >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
89 nếu đối số của nó là có thể gọi được và >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
08 khác.Khi bạn chắc chắn rằng
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 là một đối tượng có thể gọi được, thì bạn sẽ xây dựng danh sách các khóa so sánh bằng cách áp dụng >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 cho mỗi giá trị trong dữ liệu đầu vào.Cuối cùng, nếu
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 không phải là một đối tượng có thể gọi được, thì mệnh đề min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
46 chạy, tăng >>> min[[3, 5, 9, 1, -5]]
-5
>>> min[[]]
Traceback [most recent call last]:
...
ValueError: min[] arg is an empty sequence
>>> max[[3, 5, 9, 1, -5]]
9
>>> max[[]]
Traceback [most recent call last]:
...
ValueError: max[] arg is an empty sequence
04, giống như min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 làm trong một tình huống tương tự.Tìm giá trị tối thiểu và tối đa
Bước cuối cùng để hoàn thành chức năng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 của bạn là tìm các giá trị tối thiểu và tối đa trong dữ liệu đầu vào, giống như min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 làm. Đi trước và kết thúc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 với mã sau:min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
0Bạn đặt các biến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
82 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
83 thành giá trị đầu tiên trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
84 và trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49, tương ứng. Các biến này sẽ cung cấp khóa và giá trị ban đầu để tính toán tối thiểu và tối đa.Sau đó, bạn lặp qua các khóa và giá trị còn lại trong một lần sử dụng hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
86 tích hợp. Hàm này sẽ mang lại các bộ dữ liệu giá trị khóa bằng cách kết hợp các giá trị trong danh sách min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
84 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49 của bạn.Có điều kiện bên trong vòng lặp gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22 để so sánh >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 hiện tại với phím tối thiểu hoặc phím tối đa được lưu trữ trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
82. Tại thời điểm này, đối số min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22 sẽ giữ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
93 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
94 từ mô -đun min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22, tùy thuộc vào việc bạn muốn tìm giá trị tối thiểu hoặc tối đa, tương ứng.Ví dụ: khi bạn muốn tìm giá trị nhỏ nhất trong dữ liệu đầu vào,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22 sẽ giữ hàm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
93. Khi bạn muốn tìm giá trị lớn nhất, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22 sẽ giữ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
94.Mỗi lần lặp vòng lặp đều so sánh
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 hiện tại với khóa tối thiểu hoặc tối đa dự kiến và cập nhật các giá trị của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
82 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
83. Ở cuối vòng lặp, các biến này sẽ giữ khóa tối thiểu hoặc tối đa và giá trị tương ứng của nó. Cuối cùng, bạn chỉ cần trả về giá trị trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
83.Mã hóa các chức năng tùy chỉnh min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 của bạn
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Với chức năng trợ giúp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 tại chỗ, bạn có thể xác định các phiên bản tùy chỉnh của mình là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Đi trước và thêm các chức năng sau vào cuối tệp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
32 của bạn:min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
1Trong đoạn mã này, trước tiên bạn nhập
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
94 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
93 từ mô -đun min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22. Các chức năng này tương đương chức năng của các toán tử lớn hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
36] và nhỏ hơn [>>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
35], tương ứng. Ví dụ: biểu thức boolean >>> min[[3, "5.0", 9, 1.0, "-5"]]
Traceback [most recent call last]:
...
TypeError: '' not supported between instances of 'str' and 'int'
37 tương đương với chức năng gọi >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
16. Bạn sẽ sử dụng các chức năng này để cung cấp đối số min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22 cho min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 của bạn.Giống như
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
21 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
22 lấy min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
16, >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
3 và >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
4 làm đối số và trả về các giá trị tối thiểu và tối đa, tương ứng. Để thực hiện tính toán, các chức năng này gọi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
25 với các đối số cần thiết và với hàm so sánh thích hợp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
22.Trong
>>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
21, bạn sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
93 để tìm giá trị nhỏ nhất trong dữ liệu đầu vào. Trong >>> min[3, 5, 9, 1, -5]
-5
>>> max[3, 5, 9, 1, -5]
9
22, bạn sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
94 để có được giá trị lớn nhất.Nhấp vào phần Thu gọn bên dưới nếu bạn muốn lấy toàn bộ nội dung của tệp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
32 của mình:min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
2Mát mẻ! Bạn đã hoàn thành mã hóa các phiên bản của riêng mình là
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trong Python. Bây giờ hãy tiếp tục và cho họ một thử!Sự kết luận
Bây giờ bạn đã biết cách sử dụng các hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 tích hợp của Python để tìm các giá trị nhỏ nhất và lớn nhất trong một loạt hoặc trong một loạt hai hoặc nhiều đối số thông thường. Bạn cũng đã tìm hiểu về một vài đặc điểm khác của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có thể làm cho chúng hữu ích trong chương trình hàng ngày của bạn.smallest and largest values in an iterable or in a series of two or more regular arguments. You also learned about a few other characteristics of min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 and min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 that can make them useful in your day-to-day programming.Trong hướng dẫn này, bạn đã học được cách:
- Tìm các giá trị nhỏ nhất và lớn nhất bằng cách sử dụng Python từ
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, tương ứngsmallest and largest values using Python’smin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 andmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, respectivelymin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Gọi
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với một điều duy nhất và với một số đối số thông thườngiterable and with several regular argumentsmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Sử dụng
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và từ điểnstrings and dictionariesmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Tùy chỉnh hành vi của
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 vớimin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
4>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
3 and>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
4>>> min[3, 5, 9, 1, -5] -5 >>> max[3, 5, 9, 1, -5] 9
- Feed Tolefersions và trình tạo biểu thức vào
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4comprehensions and generator expressions intomin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 andmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Ngoài ra, bạn đã mã hóa một số ít các ví dụ thực tế bằng cách sử dụng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 để tiếp cận các vấn đề trong thế giới thực mà bạn có thể gặp phải trong khi mã hóa. Bạn cũng là một phiên bản tùy chỉnh bằng văn bản của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trong Pure Python, một bài tập học tập đẹp giúp bạn hiểu logic đằng sau các chức năng tích hợp này.real-world problems that you might run into while coding. You’ve also a written custom version of min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 and min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 in pure Python, a nice learning exercise that helped you understand the logic behind these built-in functions.