Hướng dẫn how do you set a minimum value in python? - làm cách nào để bạn đặt giá trị tối thiểu trong python?

Python 3

Trong Python 3, câu hỏi này không được áp dụng. Loại

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
4 đơn giản là không liên kết.

Show

Tuy nhiên, bạn thực sự có thể đang tìm kiếm thông tin về kích thước từ của trình thông dịch hiện tại, sẽ giống như kích thước từ của máy trong hầu hết các trường hợp. Thông tin đó vẫn có sẵn trong Python 3 là

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
5, đây là giá trị tối đa có thể được thể hiện bằng một từ đã ký. Tương tự, đó là kích thước của danh sách lớn nhất có thể hoặc trình tự trong bộ nhớ.

Nói chung, giá trị tối đa có thể được biểu thị bằng một từ không dấu sẽ là

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
6 và số lượng bit trong một từ sẽ là
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
7. Xem câu trả lời này để biết thêm thông tin.

Python 2

Trong Python 2, giá trị tối đa cho các giá trị

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
4 có sẵn là
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
9:

>>> sys.maxint
9223372036854775807

Bạn có thể tính giá trị tối thiểu với

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
0 như được hiển thị ở đây.

Python liền mạch chuyển từ số nguyên đơn giản sang số nguyên dài khi bạn vượt quá giá trị này. Vì vậy, hầu hết thời gian, bạn sẽ không cần phải biết điều đó.

Các chức năng

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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 đối số 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ừ
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 để 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 data
  • Gọi
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 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 arguments
  • Sử dụng
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 với chuỗi và từ điểnstrings and dictionaries
  • Điều chỉnh hành vi của
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 với các đối số
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    1 và
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    2
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    1
    and
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    2
    arguments
  • Sử dụng các biểu thức toàn diện và trình tạo làm đối số cho
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2comprehensions and generator expressions as arguments to
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
9 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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. 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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, 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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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ñ")
'ñ'
2 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
2 và
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1.

Ở đâ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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 làm:

Tranh luậnSự mô tảYêu cầu
>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'
2
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
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2
Giữ một giá trị để trả về nếu có thể đầu vào có thể trốngKhông
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1
Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánhKhông

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
2 và
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 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ñ")
'ñ'
2, đâ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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trong 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

Trong các ví dụ này, bạn gọi

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với danh sách các số nguyên và sau đó với một danh sách trống. Cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 trả về số nhỏ nhất trong danh sách đầu vào,
>>> ord("A")
65

>>> ord("a")
97
8. Ngược lại, cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trả về số lớn nhất trong danh sách hoặc
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
00. Nếu bạn chuyển một trình lặp trống đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, thì bạn sẽ nhận được một
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
03 bởi vì không có gì để làm trên một khoảng trống.

Một chi tiết quan trọng cần lưu ý về

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 là tất cả các giá trị trong đầu vào có thể so sánh được. Nếu không, bạn gặp lỗi. Ví dụ: các giá trị số hoạt động ổn:

>>>

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9

Trong các ví dụ này, bạn gọi

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với danh sách các số nguyên và sau đó với một danh sách trống. Cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 trả về số nhỏ nhất trong danh sách đầu vào,
>>> ord("A")
65

>>> ord("a")
97
8. Ngược lại, cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trả về số lớn nhất trong danh sách hoặc
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
00. Nếu bạn chuyển một trình lặp trống đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, thì bạn sẽ nhận được một
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
03 bởi vì không có gì để làm trên một khoảng trống.

Một chi tiết quan trọng cần lưu ý về

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 là tất cả các giá trị trong đầu vào có thể so sánh được. Nếu không, bạn gặp lỗi. Ví dụ: các giá trị số hoạt động ổn:

>>>

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'

Trong các ví dụ này, bạn gọi

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với danh sách các số nguyên và sau đó với một danh sách trống. Cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 trả về số nhỏ nhất trong danh sách đầu vào,
>>> ord("A")
65

>>> ord("a")
97
8. Ngược lại, cuộc gọi đầu tiên đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trả về số lớn nhất trong danh sách hoặc
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
00. Nếu bạn chuyển một trình lặp trống đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, thì bạn sẽ nhận được một
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
03 bởi vì không có gì để làm trên một khoảng trống.

Một chi tiết quan trọng cần lưu ý về min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 là tất cả các giá trị trong đầu vào có thể so sánh được. Nếu không, bạn gặp lỗi. Ví dụ: các giá trị số hoạt động ổn:

Các ví dụ này kết hợp các số

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
4 và
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
07 trong các 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. Bạn nhận được kết quả dự kiến ​​trong cả hai trường hợp vì các loại dữ liệu này có thể so sánh được.

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value

Tuy nhiên, điều gì sẽ xảy ra nếu bạn trộn chuỗi và số? Kiểm tra các ví dụ sau:

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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với một loại không thể so sánh được như một đối số. Trong ví dụ này, một hàm cố gắng so sánh một số với một chuỗi, giống như so sánh táo và cam. Kết quả cuối cùng mà bạn nhận được
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12.
Gọi
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với nhiều đối số
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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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:
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:Tranh luậnSự mô tả
Yêu cầu
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
17
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ọ)

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1

>>>

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9

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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 không có đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2. 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
2 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:

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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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.

>>>

>>> min("abcdefghijklmnopqrstuvwxyz")
'a'

>>> max("abcdefghijklmnopqrstuvwxyz")
'z'

>>> min("abcdWXYZ")
'W'

>>> max("abcdWXYZ")
'd'

Sử dụng

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với chuỗi và vòng lặp của chuỗi

Theo mặc định,

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12, 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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.

>>>

>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để 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:

>>>

>>> ord("A")
65

>>> ord("a")
97

Chức năng

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
50 tích hợp của Python có một ký tự Unicode duy nhất và trả về một số nguyên đại diện cho điểm mã Unicode của ký tự đó. Trong các ví dụ này, điểm mã cho chữ hoa
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
51 thấp hơn điểm mã cho chữ thường
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
52.Unicode code point of that character. In these examples, the code point for the uppercase
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
51 is lower than the code point for the lowercase
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
52.

Bằng cách này, khi bạn gọi

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với cả hai chữ cái, bạn sẽ nhận được kết quả phù hợp với thứ tự của các điểm mã Unicode cơ bản của các chữ cái này:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
0

Điều gì làm cho

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
51 nhỏ hơn
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
52? Câu trả lời nhanh là điểm mã unicode thư. Tất cả các ký tự mà bạn có thể nhập trên bàn phím của mình và nhiều ký tự khác, có các điểm mã của riêng họ trong bảng Unicode. Python sử dụng các điểm mã này để xác định ký tự tối thiểu và tối đa khi sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2.

Cuối cùng, 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 với các chuỗi lặp hoặc với nhiều đối số chuỗi. Một lần nữa, cả hai hàm sẽ xác định giá trị trả về của chúng bằng cách so sánh các chuỗi theo thứ tự bảng chữ cái:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
1

Để tìm chuỗi nhỏ nhất hoặc lớn nhất trong một chuỗi 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 so sánh tất cả các chuỗi theo bảng chữ cái dựa trên các điểm mã của các ký tự ban đầu.

Trong ví dụ đầu tiên, chữ hoa

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
63 xuất hiện trước
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
64,
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
52 và
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
66 trong bảng Unicode. Vì vậy,
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 ngay lập tức kết luận rằng
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
68 là chuỗi nhỏ nhất. Trong ví dụ thứ hai, chữ thường
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
66 xuất hiện sau tất cả các chuỗi ban đầu khác.

Lưu ý rằng có hai từ bắt đầu bằng

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
66,
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
71 và
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
72. 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
2 trả về
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
72 vì
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
75 xuất hiện sau
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
76.

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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
2

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
1 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, 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
2 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
84 trên từ điển đầu vào của mình:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
3

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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
82, 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
86:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
4

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
1 đi qua tất cả các giá trị trong
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
82 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
2 lặp lại các giá trị của
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
82 và trả về giá tối đa.

Cuối cùng, bạn cũng có thể sử dụng phương thức

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
91 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:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
5

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
94 có lớn hơn
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
95), các thử nghiệm Python
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
96. Nếu điều kiện này là
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
97, 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
98, thì Python kết luận rằng tuple thứ nhất nhỏ hơn lần thứ hai.

Cuối cùng, nếu

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
99, thì Python so sánh cặp mục thứ hai bằng cách sử dụng cùng một quy tắc. Lưu ý rằng trong bối cảnh này, mục đầu tiên của mỗi bộ tuple đến từ các khóa từ điển và vì các khóa từ điển là duy nhất, các mục có thể bằng nhau. Vì vậy, Python sẽ không bao giờ phải so sánh các giá trị thứ hai.

Điều chỉnh 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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 với >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 1 và >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 2

Cho đến thời điểm này, bạn đã học được cách

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 hoạt động ở dạng tiêu chuẩn của họ. Trong phần này, bạn sẽ học cách điều chỉnh hành vi tiêu chuẩn của cả hai chức năng bằng cách sử dụng các đối số từ khóa
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 và
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2.keyword-only arguments.

Đối số

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 thành
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 cho phép bạn cung cấp chức năng đơn lẻ sẽ được áp dụng cho mọi giá trị trong dữ liệu đầu vào. Mục tiêu là sửa đổi các tiêu chí so sánh để sử dụng trong việc tìm kiếm giá trị tối thiểu hoặc tối đa.

Như một ví dụ về cách tính năng này có thể hữu ích, hãy nói rằng bạn có một danh sách các số dưới dạng chuỗi và muốn tìm các số nhỏ nhất và lớn nhất. Nếu bạn xử lý danh sách trực tiếp với

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, thì bạn sẽ nhận được kết quả sau:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
6

Đây có thể không phải là kết quả mà bạn cần hoặc mong đợi. Bạn có thể nhận được các chuỗi nhỏ nhất và lớn nhất dựa trên các quy tắc so sánh chuỗi Python thay vì dựa trên giá trị số thực tế của mỗi chuỗi.

Trong trường hợp đó, giải pháp là chuyển chức 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
13 tích hợp như đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 cho
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, như trong các ví dụ sau:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
7

Tuyệt quá! Bây giờ kết quả của

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 phụ thuộc vào các giá trị số của các chuỗi cơ bản. Lưu ý rằng bạn không cần phải gọ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
13. Bạn chỉ cần vượt qua
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
4 mà không có cặp dấu ngoặc đơn vì
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 mong đợi một đối tượng hàm, hoặc chính xác hơn là một đối tượng có thể gọi được.function object, or more accurately, a callable object.

Đối số chỉ từ khóa thứ hai cho phép bạn tùy chỉnh 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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 là
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2. Hãy nhớ rằng đối số này chỉ có sẵn khi bạn gọi hàm với một điều có thể xảy ra như một đối số.

Công việc của

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2 là cung cấp giá trị mặc định phù hợp vì giá trị trả về của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 khi nó được gọi với một khoảng trống có thể trống:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
8

Trong các ví dụ này, đầu vào có thể lặp lại là một danh sách trống. Hành vi tiêu chuẩn là dành cho

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để nâng cao
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
03 phàn nàn về đối số trình tự trống. Tuy nhiên, vì bạn cung cấp giá trị cho
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2, cả hai chức năng hiện trả về giá trị này thay vì tăng một ngoại lệ và phá mã của 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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 với các biểu thức toàn diện và trình tạo

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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, giá trị kết quả sẽ đến từ dữ liệu được chuyển đổi thay vì từ dữ liệu gốc:

>>>

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
9

Cuộ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
1 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, 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
39 bằng cách áp 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
40 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
52, 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
2.

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
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1. 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
1, 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
0

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
1 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
40 để 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. Vì vậy, nó luôn luôn hiệu quả hơn để sử dụng biểu thức máy phát.generator expression instead.

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

Sự khác biệt cú pháp chính là biểu thức máy phát sử dụng dấu ngoặc đơn thay vì dấu ngoặc vuô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
51). Bởi vì một cuộc gọi chức năng đã yêu cầu dấu ngoặc đơn, bạn chỉ cần loại bỏ các dấu ngoặc vuông khỏi các ví dụ dựa trên sự hiểu biết của bạn và bạn có thể đi tốt. Không giống như toàn bộ danh sách, các biểu thức tạo mang lại các mục theo yêu cầu, điều này làm cho chúng hiệu quả bộ nhớ.

Đưa Python từ min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 vào hành động

Cho đến nay, bạn đã học được những điều cơ bản 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để tìm các giá trị nhỏ nhất và lớn nhất trong một giá trị có thể lặp lại hoặc trong một loạt các giá trị riêng lẻ. Bạn đã học cách
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 hoạt động với các loại dữ liệu Python tích hợp khác nhau, chẳng hạn như số, chuỗi và từ điển. Bạn cũng đã khám phá cách điều chỉnh hành vi tiêu chuẩn của các chức năng này và cách sử dụng chúng với sự hiểu biết danh sách và biểu thức máy phát.

Bây giờ bạn đã sẵn sàng để bắt đầu mã hóa một vài ví dụ thực tế sẽ chỉ cho bạn 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trong mã của riêng bạn.

Loại bỏ các số nhỏ nhất và lớn nhất trong danh sách

Để khởi động mọi thứ, bạn sẽ bắt đầu với một ví dụ ngắn về cách xóa các giá trị tối thiểu và tối đa khỏi danh sách các số. Để làm điều đó, bạn có thể gọ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
60 trên danh sách đầu vào của mình. Tùy thuộc vào nhu cầu của bạn, bạn sẽ sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để chọn giá trị mà bạn sẽ xóa khỏi danh sách cơ bả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
2

Trong các ví dụ này, các giá trị tối thiểu và tối đa 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
63 có thể là điểm dữ liệu ngoại lệ mà bạn muốn xóa để chúng không ảnh hưởng đến phân tích thêm của bạn. Ở đây,
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 cung cấp các đối số cho
>>> 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
60.

Danh sách xây dựng các giá trị tối thiểu và tối đa

Bây giờ nói rằng bạn có một danh sách các danh sách đại diện cho một ma trận các giá trị số và bạn cần xây dựng danh sách chứa các giá trị nhỏ nhất và lớn nhất từ ​​mỗi hàng trong ma trận đầu vào. Để làm điều này, 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 cùng với danh sách hiể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
3

Độ hiểu hiểu đầu tiên lặp lại trên các nhóm phụ 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
69 và sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 để xây dựng một danh sách chứa giá trị nhỏ nhất từ ​​mỗi người phụ. Sự hiểu biết thứ hai thực hiện một nhiệm vụ tương tự nhưng sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để tạo một danh sách chứa các giá trị lớn nhất từ ​​các nhóm phụ 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
69.

Mặc dù

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 cung cấp một cách nhanh chóng để đối phó với các ví dụ trong phần này, thư viện Numpy rất được khuyến khích khi xử lý ma trận trong Python vì Numpy có các công cụ cụ thể và tối ưu hóa cho công việc.

Cắt các giá trị vào các cạnh của một khoảng thời gian

Đôi khi bạn có một danh sách các giá trị số và muốn cắt chúng đến các cạnh hoặc giới hạn của một khoảng thời gian nhất định. Ví dụ: nếu một giá trị nhất định lớn hơn giới hạn trên của khoảng thời gian, thì bạn cần chuyển đổi nó xuống giới hạn đó. Để thực hiện thao tác này, 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
1.

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
1? 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, 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
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
1 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
1 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, 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
79 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
80 được cắt thà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
81, đó 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
2, như trong ví dụ 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
5

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
2 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
2 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, 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
85 là số duy nhất được cắt.

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. Đây là cách làm điề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
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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. 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
1 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
2 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, 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
92 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:

>>>

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

Trong ví dụ này, trước tiên bạn nhậ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
93 để có quyền truy cập 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
94. 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.

Hàm

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 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
1 của nó. Trong ví dụ này,
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 có hàm
>>> 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
98 tính toán 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
1 để 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, 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
98 vì
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 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
02 yêu cầu hai đối số. Vì vậy, hàm
>>> 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
98 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
04, 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
02.

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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
91 và chức 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
98 thích hợp như đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1:

>>>

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

Trong ví dụ này, hàm

>>> 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
98 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1 để 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à một ước số chung không phải là
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
13.

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:predicate function like the following:

>>>

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

Trong đoạn mã này, bạn xác định

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
14 là hàm vị ngữ trả về
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
97 nếu các số đầu vào là coprime. Nếu các số aren coprime, thì hàm trả về
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
16.

Thành phần chính của chức năng là một vòng

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
9 lặp đi lặp lại trên
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
18 của các giá trị. Để đặt giới hạn trên cho đối tượng
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
18 này, 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
1 với các số đầu vào làm đối số. Một lần nữa, 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
1 để đặt giới hạn trên của một số khoảng.

Thời gian các triển khai khác nhau của mã của bạn

Bạn cũng 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
1 để so sánh một số thuật toán của mình, đánh giá thời gian thực hiện của chúng và xác định thuật toán nào là hiệu quả nhất. Ví dụ dưới đây sử dụng
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
23 để đo thời gian thực hiện cho hai cách khác nhau để xây dựng danh sách chứa các giá trị vuông của các số từ
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
24 đến
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
25:

>>>

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
0

Cuộc gọi đến

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
23 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
1 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
1,
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
29 và các chức năng 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 ____330 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]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 31 và >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 32 trong min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 tích hợp là đủ linh hoạt để 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 Embrace 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32.

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

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 hỗ trợ các toán tử nhỏ hơn (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
43) và lớn hơn (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
44), 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
45 trong mã của bạn, nó sẽ làm
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
46.rich comparison methods. Specifically,
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 and
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 support the less than (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
43) and greater than (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
44) operators, respectively. What’s the meaning of support here? When Python finds something like
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
45 in your code, it internally does
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
46.

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32. Đó 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
1

Cá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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32. 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. Để đạ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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32. Hãy xem xét lớp
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
59 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
2

Lưu ý rằng việc triển khai

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 yêu cầu một đối số mà thường có tên là
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
62. Đố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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
45, bạn sẽ có
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
64 sẽ là
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
65 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
66 sẽ là
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
62.

Trong ví dụ này,

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 trả về kết quả của việc so sánh hai người ____ ____370. Ở đây, cách thức hoạt động của nó trong thực tế:

>>>

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
3

Mát mẻ! Bạn có thể xử lý các đối tượng

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
59 với
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 vì lớp cung cấp triển khai
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32. 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
1 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
2 trả về 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 thức 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2:

>>>

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
4

Bởi vì lớp

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
80 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32,
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 trả lời với
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12. 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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2

Cho đến thời điểm này, bạn đã học được cách hoạt động của Python,

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. 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 được 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2.

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để 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 của riêng bạn là

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2.

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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2

Để 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
5

Trong đoạn mã này, bạn xác định

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
98. Hàm này giả định rằng
>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'
2 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à

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 dự kiến. Sau đó, vòng lặp
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
9 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00, 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 được cập nhật. Khi hàm đạt đến cuối
>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'
2,
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
98 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
43) thành lớn hơn (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
44) 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
6

Trong đoạn mã này, bạn xác định

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
98. Hàm này giả định rằng
>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'
2 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à

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 dự kiến. Sau đó, vòng lặp
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
9 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00, 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
02 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 được cập nhật. Khi hàm đạt đến cuối
>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'
2,
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
00 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]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 98 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]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 43) thành lớn hơn (>>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 44) 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:

Lưu ý rằng

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
14 chia sẻ hầu hết mã của nó với
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
98. Sự khác biệt quan trọng nhất, ngoài việc đặt 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
14 sử dụng người vận hành lớn hơn (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
44) thay vì ít hơn toán tử (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
43).

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
7

Là 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
98 và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
14 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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.

Trước khi lặn vào, bạn cần phải nhận thức được các yêu cầu kiến ​​thức. Bạn sẽ kết hợp các chủ đề như báo cáo có điều kiện, xử lý ngoại lệ, trình biết danh sách, lặp lại xác định với các vòng
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
9 và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24 và các đối số tùy chọn trong các chức năng.
Nếu bạn cảm thấy rằng bạn không biết mọi thứ về các chủ đề này, thì đừng lo lắng. Bạn sẽ học bằng cách làm. Nếu bạn bị mắc kẹt, thì bạn có thể quay lại và xem lại các tài nguyên được liên kết.Lập kế hoạch cho các phiên bản tùy chỉnh
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 của bạn
Để viết các triển khai tùy chỉnh của bạn là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2, 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ậnSự mô tảỞ đây, những gì mỗi đối số làm:
Tranh luậnSự mô tảYêu cầu
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24
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ườngKhông

Phần thân của

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 sẽ bắt đầu bằng cách xử lý
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24 để xây dựng danh sách các giá trị. Có một danh sách các giá trị được tiêu chuẩn hóa sẽ cho phép bạn viết thuật toán cần thiết để tìm các giá trị tối thiểu và tối đa trong dữ liệu đầu vào.

Sau đó, chức năng cần phải đối phó với các đối số

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 và
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2 trước khi tính toán mức tối thiểu và tối đa, đó là bước cuối cùng bên trong
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33.

Với

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 tại chỗ, bước cuối cùng là xác định hai chức năng độc lập trên đầu nó. Các chức năng này sẽ sử dụng các hàm vận hành so sánh thích hợp để tìm các giá trị tối thiểu và tối đa tương ứng. Bạn sẽ tìm hiểu thêm về các chức năng của nhà điều hành trong một khoảnh khắc.operator functions to find the minimum and maximum values, respectively. You’ll learn more about operator functions in a moment.

Tiêu chuẩn hóa dữ liệu đầu vào từ >>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 24

Để chuẩn hóa dữ liệu đầu vào, bạn cần kiểm tra xem người dùng có cung cấp một số không thể điều khiển được hoặc bất kỳ số lượng đối số thông thường nào không. Fun lên trình chỉnh sửa mã yêu thích của bạn hoặc IDE và tạo một tệp Python mới 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
40. Sau đó thêm đoạn mã sau vào nó:

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
8

Ở đâ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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33. Phần đầu tiên của chức năng tiêu chuẩn hóa dữ liệu đầu vào để xử lý thêm. Vì người dùng sẽ có thể gọi
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 với một lần lặp lại hoặc có một số đối số thông thường, bạn cần kiểm tra độ dài của
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
43. Để thực hiện kiểm tra này, bạn sử dụng chức năng
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
44 tích hợp.

Nếu

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
43 chỉ giữ một giá trị, thì bạn cần kiểm tra xem đối số đó có phải là đối tượng không. Bạn sử dụng
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
46, trong đó hoàn toàn kiểm tra và cũng biến đầu vào có thể lặp lại thành một danh sách.

Nếu

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
46 tăng
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12, thì bạn sẽ bắt nó và tự nâng
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 làm ở dạng tiêu chuẩn của họ. Lưu ý rằng bạn sử dụng cú pháp
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
52 để ẩn đi dấu vết của
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12 ban đầu.

Chi nhánh

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
54 chạy khi
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
43 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(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12, thì
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
57 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 2

Để tiếp tục viết

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33, 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
2. Đi trước và thêm mã sau vào cuối hàm:

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
9

Trong đoạn mã này, bạn xác định một điều kiện để kiểm tra xem

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
57 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
2 để 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
2 vẫn là
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
64, thì
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
03 được nâng lên. Nếu không,
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2 đượ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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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 1 tùy chọn

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
1 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
1 được cung cấp. Đi trước và cập nhật
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
0

Bạ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 đã không cung cấp chức năng

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1. 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
57 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
1, 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
76 tích hợp, trả về
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
97 nếu đối số của nó là có thể gọi được và
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
16 nếu không.

Khi bạn chắc chắn rằng

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 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
1 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
1 không phải là một đối tượng có thể gọi được, thì mệnh đề
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
54 chạy, tăng
min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value
12, giống như
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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 hàm

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 làm. Đi trước và kết thúc
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 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'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
1

Bạn đặt các biến

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90 và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
91 thành giá trị đầu tiên trong
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 và trong
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
57, 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
57 của bạn.

Có điều kiện bên trong vòng lặp gọi

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30 để so sánh
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90. Tại thời điểm này, đối số
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30 sẽ giữ
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
01 hoặc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
02 từ mô -đun
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30, 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30 sẽ giữ hàm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
01. Khi bạn muốn tìm giá trị lớn nhất,
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30 sẽ giữ
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
02.

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
1 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90 và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
91. Ở 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
91.

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 1 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 2 của bạn

Với chức năng trợ giúp

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2. Đi trước và thêm các chức năng sau vào cuối tệp
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
40 của bạn:

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
2

Trong đ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
02 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
01 từ mô -đun
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30. 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])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
44) và nhỏ hơn (
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
43), tương ứng. Ví dụ: biểu thức boolean
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
45 tương đương với chức năng gọi
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
24. Bạn sẽ sử dụng các chức năng này để cung cấp đối số
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30 cho
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2,
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
29 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
30 lấy
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24,
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
1 và
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
2 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
33 với các đối số cần thiết và với hàm so sánh thích hợp
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
30.

Trong

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
29, 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
01 để tìm giá trị nhỏ nhất trong dữ liệu đầu vào. Trong
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
30, 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
02 để 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([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
40 của mình:

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
3

Má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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 tích hợp 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1 and
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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ừ
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2, tương ứngsmallest and largest values using Python’s
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2, respectively
  • Gọi
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 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 arguments
  • Sử dụng
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 với chuỗi và từ điểnstrings and dictionaries
  • Tùy chỉnh hành vi của
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2 với
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    1 và
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    2
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    1
    and
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    2
  • Feed Tolefersions và Trình tạo biểu thức vào
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2comprehensions and generator expressions into
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    1 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    2

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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 để 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
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 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
1 and
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
2 in pure Python, a nice learning exercise that helped you understand the logic behind these built-in functions.

Làm thế nào để bạn viết tối thiểu trong Python?

Hàm Min () được viết dưới hai dạng:..
Cú pháp để tìm mục nhỏ nhất trong một tối thiểu có thể lặp lại (có thể lặp lại, *iterables, khóa, mặc định) ....
Cú pháp để tìm mục nhỏ nhất giữa hai hoặc nhiều đối tượng tối thiểu (arg1, arg2, *args, khóa) ....
Arg1 - một đối tượng; Có thể là số, chuỗi, vv ....
Arg2 - một đối tượng; có thể là số, chuỗi, vv ..

Làm thế nào để bạn tìm thấy giá trị tối thiểu trong Python?

Sử dụng Python's Min () và Max () để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạn.Gọi Min () và Max () 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ào.Sử dụng Min () và Max () với chuỗi và từ điển.. Call min() and max() with a single iterable or with any number of regular arguments. Use min() and max() with strings and dictionaries.

Làm thế nào để bạn gán tối thiểu cho INT trong Python?

Trong Python 2, thêm 1 vào Maxint cho int dài nhất có thể và trong Python 2.7, trừ 1 từ Maxint mang lại giá trị nhỏ nhất có thể cho một số nguyên.subtracting 1 from maxint gives the smallest possible value for an integer.

Làm thế nào để bạn đặt một giá trị tối đa trong Python?

Python Max ()..
Max () với các lập luận có thể lặp lại.Cú pháp tối đa ().Để tìm ra mục lớn nhất trong một điều khác, chúng tôi sử dụng cú pháp này: tối đa (có thể sử dụng được, *iterables, khóa, mặc định) tối đa) tham số.....
Max () mà không có sự khác biệt.Cú pháp tối đa ().Để tìm đối tượng lớn nhất giữa hai hoặc nhiều tham số, chúng ta có thể sử dụng cú pháp này: MAX (Arg1, Arg2, *Args, khóa).