Hướng dẫn how to find max() in python - cách tìm max() trong python

Các hàm

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 tích hợp của Python có ích khi bạn cần tìm các giá trị nhỏ nhất và lớn nhất trong một cuộc tranh luận thông thường hoặc trong một loạt các đối số thông thường. Mặc dù những điều này có vẻ giống như các tính toán khá cơ bản, chúng hóa ra có nhiều trường hợp sử dụng thú vị trong lập trình trong thế giới thực. Bạn sẽ thử một số trường hợp sử dụng ở đây.smallest and largest values in an iterable or in a series of regular arguments. Even though these might seem like fairly basic computations, they turn out to have many interesting use cases in real-world programing. You’ll try out some of those use cases here.

Show

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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạnsmallest and largest values in your data
  • Gọi
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với một 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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với chuỗi và từ điểnstrings and 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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với các đối số
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    3 và
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    4
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    3
    and
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    4
    arguments
  • 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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4comprehensions and generator expressions as arguments to
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    3 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4

Khi bạn có kiến ​​thức này trong vành đai của mình, thì bạn sẽ sẵn sàng viết một loạt các ví dụ thực tế sẽ thể hiện tính hữu ích của

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Cuối cùng, bạn sẽ mã hóa các phiên bản
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 của riêng mình trong Python Pure Python, điều này có thể giúp bạn hiểu cách các chức năng này hoạt động trong nội bộ.

Để tận dụng tối đa hướng dẫn này, bạn nên có một số kiến ​​thức trước đây về lập trình Python, bao gồm các chủ đề như

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

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

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

>>> max("abcdWXYZ")
'd'
1 vòng lặp, chức năng, danh sách toàn diện và biểu thức máy phát.

Bắt đầu với các chức năng Python từ min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4

Python bao gồm một số chức năng tích hợp làm cho cuộc sống của bạn dễ chịu và hiệu quả hơn vì chúng có nghĩa là bạn không cần phải phát minh lại bánh xe. Hai ví dụ về các chức năng này là

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Chúng chủ yếu áp dụng cho các vòng lặp, nhưng bạn cũng có thể sử dụng chúng với nhiều đối số thông thường. Công việc của họ là gì? Họ quan tâm đến việc tìm kiếm các giá trị nhỏ nhất và lớn nhất trong dữ liệu đầu vào của họ.

Cho dù bạn sử dụng Python từ

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4, bạn có thể sử dụng chức năng để đạt được hai hành vi hơi khác nhau. Hành vi tiêu chuẩn cho mỗi hành vi là trả về giá trị tối thiểu hoặc tối đa thông qua so sánh đơn giản của dữ liệu đầu vào khi nó đứng. Hành vi thay thế là sử dụng chức năng đơn lẻ để sửa đổi các tiêu chí so sánh trước khi tìm các giá trị nhỏ nhất và lớn nhất.

Để khám phá hành vi tiêu chuẩn của

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4, bạn có thể bắt đầu bằng cách gọi mỗi hàm với một hàm có thể lặp lại như một đối số hoặc với hai hoặc nhiều đối số thông thường. Đó là những gì bạn sẽ làm ngay lập tức.

Gọi min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với một đối số có thể lặp lại

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 tích hợp có hai chữ ký khác nhau cho phép bạn gọi chúng bằng một điều có thể được lặp lại như đối số đầu tiên của họ hoặc với hai hoặc nhiều đối số thông thường. Chữ ký chấp nhận một đối số có thể lặp lại duy nhất trông giống như sau:

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

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

Cả hai hàm đều có một đối số yêu cầu gọi là

>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4 và trả về các giá trị tối thiểu và tối đa tương ứng. Họ cũng lấy hai đối số chỉ từ khóa tùy chọn:
>>> min(3, 5, 9, 1, -5)
-5

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

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

Ở đây, một bản tóm tắt về những gì các đối số cho

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

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

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

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

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

>>> max("abc123ñ")
'ñ'
4
Lấy một đối tượng có thể đi được, như một danh sách, tuple, từ điển hoặc chuỗiĐúng
>>> min(3, 5, 9, 1, -5)
-5

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

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

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

Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence

Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số

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

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

>>> max(3, 5, 9, 1, -5)
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

>>>

Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh

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

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

Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số

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

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

>>> max(3, 5, 9, 1, -5)
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

>>>

Chấp nhận chức năng đơn lẻ để tùy chỉnh các tiêu chí so sánh

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

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

Sau đó trong hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số

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

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

>>> max(3, 5, 9, 1, -5)
9
3 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4, đây là một đối số bắt buộc, tận dụng hành vi tiêu chuẩn của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

Gọi min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với nhiều đối số

Chữ ký thứ hai của

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 cho phép bạn gọi cho họ với bất kỳ số lượng đối số nào, miễn là bạn sử dụng ít nhất hai đối số. Chữ ký này có hình thức sau:

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

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

Một lần nữa, các hàm này trả về các giá trị tối thiểu và tối đa, tương ứng. Ở đây, ý nghĩa của các đối số trong chữ ký trên:

Tranh luậnSự mô tảYêu cầ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
09
Chấp nhận bất kỳ số lượng đối số thông thường để so sánhCó (ít nhất hai trong số họ)
>>> min(3, 5, 9, 1, -5)
-5

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

Biến thể này của

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

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

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

>>> max(3, 5, 9, 1, -5)
9
4. Bạn phải cung cấp ít nhất hai đối số trong cuộc gọi cho chức năng hoạt động chính xác. Vì vậy, giá trị
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4 không cần thiết, bởi vì bạn sẽ luôn có ít nhất hai giá trị để so sánh để tìm mức tối thiểu hoặc tối đa.

Để thử chữ ký thay thế này, hãy chạy các ví dụ sau:

>>>

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

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

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.

Sử dụng min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với chuỗi và vòng lặp của chuỗi

Theo mặc định,

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 có thể xử lý các giá trị có thể so sánh. Nếu không, bạn nhận được một
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04, như bạn đã học. Cho đến thời điểm này, bạn đã thấy các ví dụ sử dụng các giá trị số trong một đối số có thể lặp lại hoặc nhiều đối số thông thường.

Sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với các giá trị số được cho là trường hợp sử dụng phổ biến và hữu ích nhất của các hàm này. Tuy nhiên, bạn cũng có thể sử dụng các chức năng với chuỗi và vòng lặp của chuỗi. Trong những trường hợp này, thứ tự bảng chữ cái của các ký tự sẽ quyết định kết quả cuối cùng.

Ví dụ: bạn có thể sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 để tìm các chữ cái nhỏ nhất và lớn nhất trong một số văn bản. Trong bối cảnh này, nhỏ nhất có nghĩa là gần nhất với đầu bảng chữ cái và lớn nhất có nghĩa là gần nhất với phần cuối của bảng chữ cái:

>>>

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

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

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

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

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.

Sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với chuỗi và vòng lặp của chuỗ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
3 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 có thể xử lý các giá trị có thể so sánh. Nếu không, bạn nhận được một
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04, như bạn đã học. Cho đến thời điểm này, bạn đã thấy các ví dụ sử dụng các giá trị số trong một đối số có thể lặp lại hoặc nhiều đối số thông thường.

>>>

>>> # UTF-8 characters

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

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

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.

>>>

>>> ord("A")
65

>>> ord("a")
97

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.Unicode code point of that character. In these examples, the code point for the uppercase
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
43 is lower than the code point for the lowercase
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44.

Sử dụng

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

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

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

>>>

>>> min("aA")
'A'

>>> max("aA")
'a'

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.

Sử dụng

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

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

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

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
0

Bạn có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với hai hoặc nhiều đối số thông thường. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa trong dữ liệu đầu vào, tương ứng. Điều kiện duy nhất là các đối số phải có thể so sánh.

Sử dụng

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

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

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

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

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
58,
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
63 và
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
64. Vì vậy, Python tiến hành nhìn vào chữ cái thứ hai của mỗi từ. Kết quả là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
64 vì
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
67 xuất hiện sau
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
68.

Xử lý từ điển với min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4

Khi nói đến việc xử lý từ điển Python với

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4, bạn cần xem xét rằng nếu bạn sử dụng trực tiếp từ điển, thì cả hai chức năng sẽ hoạt động trên các khóa:

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
1

Trong các ví dụ này,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
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
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
3

Trong các ví dụ này,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
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
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.

Một yêu cầu phổ biến khác sẽ là tìm các giá trị nhỏ nhất và lớn nhất trong từ điển. Để tiếp tục với ví dụ

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74, giả sử bạn muốn biết giá nhỏ nhất và lớn nhất. Trong tình huống này, bạn có thể sử dụng phương pháp
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
78:

Trong các ví dụ này, min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 đi qua tất cả các giá trị trong >>> min([3, 5, 9, 1, -5]) -5 >>> min([]) Traceback (most recent call last): ... ValueError: min() arg is an empty sequence >>> max([3, 5, 9, 1, -5]) 9 >>> max([]) Traceback (most recent call last): ... ValueError: max() arg is an empty sequence 74 và tìm thấy giá tối thiểu. Tương tự, min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 lặp lại các giá trị của >>> min([3, 5, 9, 1, -5]) -5 >>> min([]) Traceback (most recent call last): ... ValueError: min() arg is an empty sequence >>> max([3, 5, 9, 1, -5]) 9 >>> max([]) Traceback (most recent call last): ... ValueError: max() arg is an empty sequence 74 và trả về giá tối đa.

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

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
83 trên từ điển đầu vào để tìm các cặp giá trị khóa tối thiểu và tối đa:keyword-only arguments.

Trong trường hợp này,

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 sử dụng các quy tắc nội bộ của Python, để so sánh các bộ dữ liệu và tìm các mục nhỏ nhất và lớn nhất trong từ điển đầu vào.

Python so sánh mục của bộ dữ liệu từng mục. Ví dụ, để xác định xem

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
86 có lớn hơn
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
87), các thử nghiệm Python
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
88. Nếu điều kiện này là
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
89, thì Python kết luận rằng bộ thứ nhất lớn hơn lần thứ hai mà không kiểm tra phần còn lại của các mục. Ngược lại, nếu
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
90, thì Python kết luận rằng tuple thứ nhất nhỏ hơn lần thứ hai.

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
5

Trong các ví dụ này,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
6

Trong các ví dụ này,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:function object, or more accurately, a callable object.

Sự khác biệt duy nhất giữa ví dụ sau này và cái trước là ở đây, mã rõ ràng hơn và rõ ràng hơn về những gì bạn đang làm. Bất cứ ai đọc mã của bạn sẽ nhanh chóng nhận ra rằng bạn muốn tìm các khóa nhỏ nhất và lớn nhất trong từ điển đầu vào.

Một yêu cầu phổ biến khác sẽ là tìm các giá trị nhỏ nhất và lớn nhất trong từ điển. Để tiếp tục với ví dụ

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74, giả sử bạn muốn biết giá nhỏ nhất và lớn nhất. Trong tình huống này, bạn có thể sử dụng phương pháp
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
78:

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
7

Trong các ví dụ này,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về khóa nhỏ nhất theo thứ tự chữ cái trong
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
74 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về cái lớn nhất. Bạn có thể nhận được kết quả tương tự bằng phương thức
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
76 trên từ điển đầu vào của mình:

Sử dụng min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với các biểu thức toàn diện và trình tạo

Bạn cũng có thể gọi

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với danh sách hiểu hoặc biểu thức trình tạo làm đối số. Tính năng này có ích khi bạn cần chuyển đổi dữ liệu đầu vào ngay trước khi tìm giá trị biến đổi tối thiểu hoặc tối đa.list comprehension or generator expression as an argument. This feature comes in handy when you need to transform the input data right before finding the minimum or maximum transformed value.

Khi bạn cung cấp danh sách hiểu biết vào

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

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

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

>>>

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
8

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
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 bằng cách áp dụng phương thức
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Lưu ý rằng sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3, kết quả đến từ dữ liệu gốc:

>>>

Cuộc gọi thứ hai đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 bằng cách áp dụng phương thức
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Lưu ý rằng sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3, kết quả đến từ dữ liệu gốc:

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
9generator expression instead.

Trong cả hai ví dụ,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sử dụng
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.

>>>

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

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

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
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 bằng cách áp dụng phương thức
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Lưu ý rằng sử dụng min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 hoặc min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3, kết quả đến từ dữ liệu gốc:

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
9

Trong cả hai ví dụ,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sử dụng
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.

Danh sách toàn diện tạo ra một danh sách đầy đủ trong bộ nhớ, thường là một hoạt động lãng phí. Thực tế này đặc biệt đúng nếu bạn không cần danh sách kết quả trong mã của bạn nữa, đây có thể là trường hợp với min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4. Vì vậy, nó luôn luôn hiệu quả hơn để sử dụng biểu thức máy phát.

Cú pháp cho các biểu thức máy phát gần giống như đối với các toàn bộ danh sách:

>>>

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

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

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
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 bằng cách áp dụng phương thức
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Lưu ý rằng sử dụng min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 hoặc min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 với khả năng hiểu danh sách tương tự như sử dụng đối số >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3, kết quả đến từ dữ liệu gốc:

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
9

>>>

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

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

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
3 lấy danh sách hiểu như một đối số. Sự hiểu biết này biến đổi dữ liệu gốc trong
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
31 bằng cách áp dụng phương thức
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 cho mỗi chữ cái. Kết quả cuối cùng là chữ thường
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
44, hiện có trong dữ liệu gốc. Một cái gì đó tương tự xảy ra với các ví dụ bao gồm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Lưu ý rằng sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với khả năng hiểu danh sách tương tự như sử dụng đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3. Sự khác biệt chính là với sự hiểu biết, kết quả cuối cùng là một giá trị được chuyển đổi, trong khi với
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3, kết quả đến từ dữ liệu gốc:

>>> min([3, 5, 9, 1, -5]) -5 >>> min([]) Traceback (most recent call last): ... ValueError: min() arg is an empty sequence >>> max([3, 5, 9, 1, -5]) 9 >>> max([]) Traceback (most recent call last): ... ValueError: max() arg is an empty sequence 9

Trong cả hai ví dụ,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sử dụng
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
32 để bằng cách nào đó sửa đổi các tiêu chí so sánh. Sự khác biệt là sự hiểu biết thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, do đó giá trị kết quả đến từ dữ liệu được chuyển đổi chứ không phải từ bản gốc.

Chờ đợi! Tại sao

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3? Bạn có thể đối phó với các giá trị lớn, có phải bạn không? Vấn đề là bạn cần so sánh từng giá trị lớn với giới hạn trên của khoảng thời gian và sau đó chọn số nhỏ hơn của cả hai. Về cơ bản, bạn sẽ đặt tất cả các giá trị lớn thành giới hạn trên được quy định:

>>>

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

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

Cuộc gọi đến

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

>>> max([3, 5.0, 9, 1.0, -5])
9
72 được cắt thành
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
73, đó là giới hạn trên của khoảng thời gian.

Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng

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

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

>>>

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

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

Cuộc gọi đến

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

>>> max([3, 5.0, 9, 1.0, -5])
9
72 được cắt thành
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
73, đó là giới hạn trên của khoảng thời gian.

Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng

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

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

>>>

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

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

Cuộc gọi đến

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 so sánh mọi số với giới hạn trên của khoảng thời gian. Nếu số mục tiêu lớn hơn giới hạn, thì
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 sẽ trả về giới hạn. Hiệu ứng ròng là tất cả các giá trị lớn hơn giới hạn hiện được cắt theo nó. Trong ví dụ này, các số
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

>>> max([3, 5.0, 9, 1.0, -5])
9
72 được cắt thành
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
73, đó là giới hạn trên của khoảng thời gian.

Ngược lại, nếu bạn muốn cắt các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian, thì bạn có thể sử dụng

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

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

Cuộc gọi này đến min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 clip các giá trị nhỏ đến giới hạn thấp hơn khoảng thời gian. Để thực hiện việc cắt này, min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 so sánh số hiện tại và giới hạn khoảng thời gian để tìm giá trị tối đa. Trong ví dụ, >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 77 là số duy nhất được cắt.

Cuối cùng, bạn có thể chạy cả hai thao tác trong một lần bằng cách kết hợp

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Đây là cách làm điều đó:

>>>

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

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

Để cắt tất cả các giá trị nằm ngoài giới hạn khoảng thời gian, sự hiểu biết này kết hợp

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Cuộc gọi đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 so sánh giá trị hiện tại với giới hạn trên của khoảng thời gian, trong khi cuộc gọi đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 so sánh kết quả với giới hạn thấp hơn. Kết quả cuối cùng là các giá trị thấp hơn hoặc lớn hơn giới hạn tương ứng được cắt theo giới hạn.

Sự hiểu biết này hoạt động tương tự như hàm

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

>>> max([3, 5.0, 9, 1.0, -5])
9
84 từ Numpy, có một mảng và giới hạn của khoảng mục tiêu, sau đó nó cắt tất cả các giá trị ngoài khoảng vào các cạnh của khoảng thời gian.

Tìm những điểm gần nhất

Bây giờ nói rằng bạn có một danh sách các bộ dữ liệu chứa các cặp giá trị đại diện cho các điểm Cartesian. Bạn muốn xử lý tất cả các cặp điểm này và tìm ra cặp nào có khoảng cách nhỏ nhất giữa các điểm. Trong tình huống này, bạn có thể làm một cái gì đó như sau:

Trong ví dụ này, trước tiên bạn nhập

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

>>> max([3, 5.0, 9, 1.0, -5])
9
85 để có quyền truy cập vào
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
86. Hàm này trả về khoảng cách Euclide giữa hai điểm, p và q, mỗi điểm được đưa ra dưới dạng một chuỗi tọa độ. Hai điểm phải có cùng số lượng kích thước.

>>>

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

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

Hàm

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 hoạt động phép thuật của nó thông qua đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3 của nó. Trong ví dụ này,
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3 có hàm
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
90 tính khoảng cách giữa hai điểm. Hàm này trở thành tiêu chí so sánh cho
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 để tìm cặp điểm với khoảng cách tối thiểu giữa các điểm.

Trong ví dụ này, bạn cần một hàm >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 90 vì >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3 mong đợi một chức năng đối số đơn, trong khi >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 94 yêu cầu hai đối số. Vì vậy, hàm >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 90 có một đối số duy nhất, >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 96 và sau đó giải nén nó thành hai đối số để đưa vào >>> min([3, 5.0, 9, 1.0, -5]) -5 >>> max([3, 5.0, 9, 1.0, -5]) 9 94.

Xác định các sản phẩm giá rẻ và đắt tiền

Bây giờ nói rằng bạn có một từ điển với tên và giá của một số sản phẩm và bạn muốn xác định các sản phẩm rẻ nhất và đắt nhất. Trong tình huống này, bạn có thể sử dụng

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
83 và hàm
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
90 thích hợp như đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3:predicate function like the following:

>>>

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

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

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

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

>>> max([3, 5.0, 9, 1.0, -5])
9
90 lấy một cặp giá trị khóa làm đối số và trả về giá trị tương ứng để
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 có tiêu chí so sánh thích hợp. Do đó, bạn có được một bộ phận với các sản phẩm rẻ nhất và đắt nhất trong dữ liệu đầu vào.

Tìm số số nguyên coprime

Một ví dụ thú vị khác về việc sử dụng min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 để giải quyết vấn đề trong thế giới thực là khi bạn cần tìm ra nếu hai số là coprime. Nói cách khác, bạn cần biết liệu số của bạn có chỉ là người chia cấp thông thường là >>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 05 hay không.

Trong tình huống đó, bạn có thể mã hóa một hàm giá trị boolean hoặc định vị như sau:

>>>

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

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

Cuộc gọi đến

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
15 chạy một câu lệnh dựa trên chuỗi một số lần nhất định. Trong các ví dụ này, tuyên bố được lặp lại ba lần. Cuộc gọi đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về thời gian thực hiện nhỏ nhất từ ​​ba lần lặp lại.

Bằng cách kết hợp

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
21 và các hàm hẹn giờ Python khác, bạn có thể có ý tưởng về thuật toán nào của bạn là hiệu quả nhất về thời gian thực hiện. Ví dụ trên cho thấy rằng các toàn bộ danh sách có thể nhanh hơn một chút so với hàm
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
22 tích hợp khi nói đến việc xây dựng các danh sách mới.

Khám phá vai trò của >>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 23 và >>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 24 trong min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4

Như bạn đã học được cho đến nay, các hàm

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 tích hợp đủ để hoạt động với các giá trị của các loại dữ liệu khác nhau, chẳng hạn như số và chuỗi. Bí mật đằng sau tính linh hoạt này là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 ôm lấy triết lý đánh máy con vịt Python bằng cách dựa vào các phương pháp đặc biệt
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

Những phương pháp này là một phần của những gì Python gọi là các phương pháp so sánh phong phú. Cụ thể,

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24 hỗ trợ các toán tử nhỏ hơn (
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
36), tương ứng. Ý nghĩa của sự hỗ trợ ở đây là gì? Khi Python tìm thấy một cái gì đó như
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
37 trong mã của bạn, nó sẽ làm
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
36) operators, respectively. What’s the meaning of support here? When Python finds something like
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

Takeaway là bạn có thể sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 với các giá trị của bất kỳ loại dữ liệu nào thực hiện
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24. Đó là lý do tại sao các chức năng này hoạt động với các giá trị của tất cả các loại dữ liệu tích hợp của Python,:

>>>

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

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

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"])
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'
23 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ì vậy, bạn có thể cung cấp bất kỳ loại dữ liệu nào trong số này vào
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4, với điều kiện duy nhất là các loại dữ liệu liên quan có thể so sánh.

Bạn cũng có thể thực hiện các phiên bản của các lớp tùy chỉnh của mình tương thích với

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Để đạt được điều này, bạn cần cung cấp các triển khai của riêng bạn
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24. Xem xét lớp
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
51 sau đây là một ví dụ về khả năng tương thích này:

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

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

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24 yêu cầu một đối số mà thường có tên là
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
54. Đối số này đại diện cho toán hạng thứ hai trong các hoạt động so sánh cơ bản. Ví dụ: trong một biểu thức như
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

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

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

Trong ví dụ này,

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24 trả về kết quả của việc so sánh hai người ____ ____362. Ở đây, cách thức hoạt động của nó trong thực tế:

>>>

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

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

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

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 vì lớp cung cấp triển khai
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
24. Lời kêu gọi
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả lại người trẻ nhất và cuộc gọi đến
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả lại người già nhất.

Lưu ý rằng nếu một lớp tùy chỉnh đã cho không cung cấp các phương pháp này, thì các trường hợp của nó đã giành được hỗ trợ

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

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

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

>>>

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

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

Bởi vì lớp

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
72 này không cung cấp các triển khai phù hợp của
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả lời với
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04. Thông báo lỗi cho bạn biết rằng các hoạt động so sánh được hỗ trợ trong lớp hiện tại của bạn.

Mô phỏng Python từ min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4

Cho đến thời điểm này, bạn đã học được cách hoạt động của Python từ ____43 và ____44. Bạn đã sử dụng chúng để tìm các giá trị nhỏ nhất và lớn nhất trong số một số số, chuỗi và hơn thế nữa. Bạn biết cách gọi các chức năng này với một điều duy nhất là một đối số hoặc với một số lượng đối số thông thường không xác định. Cuối cùng, bạn đã mã hóa một loạt các ví dụ thực tế tiếp cận các vấn đề trong thế giới thực bằng cách sử dụng

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

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

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

Mặc dù Python vui lòng cung cấp cho bạn

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạn, việc học cách thực hiện tính toán này từ đầu là một bài tập hữu ích có thể cải thiện tư duy logic và kỹ năng lập trình của bạn.

Trong phần này, bạn sẽ học cách tìm các giá trị tối thiểu và tối đa trong dữ liệu của bạn. Bạn cũng sẽ học cách thực hiện các phiên bản

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

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

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

Hiểu mã đằng sau min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4

Để tìm giá trị tối thiểu trong một danh sách nhỏ các số với tư cách là con người, bạn thường kiểm tra các số và ngầm so sánh tất cả chúng trong tâm trí bạn. Vâng, bộ não của bạn thật tuyệt vời! Tuy nhiên, máy tính không thông minh. Họ cần hướng dẫn chi tiết để hoàn thành bất kỳ nhiệm vụ.

Bạn phải nói với máy tính của mình để lặp lại tất cả các giá trị trong khi so sánh chúng theo cặp. Trong quá trình, máy tính phải lưu ý đến giá trị tối thiểu hiện tại trong mỗi cặp cho đến khi danh sách các giá trị được xử lý hoàn toàn.

Giải thích này có thể khó hình dung, vì vậy, đây là một chức năng Python thực hiện công việc:

>>>

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

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90. Hàm này giả định rằng
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4 không phải là trống và các giá trị của nó theo thứ tự tùy ý.

Hàm coi giá trị đầu tiên là một

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

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

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

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

>>> max("abcdWXYZ")
'd'
1 lặp lại phần còn lại của các phần tử trong dữ liệu đầu vào.

Tuyên bố có điều kiện so sánh

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại với
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 dự kiến ​​trong lần lặp đầu tiên. Nếu
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại nhỏ hơn
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92, thì các bản cập nhật có điều kiện
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

Mỗi lần lặp mới so sánh

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại với
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 sẽ giữ giá trị nhỏ nhất trong dữ liệu đầu vào.

Mát mẻ! Bạn đã mã hóa một hàm tìm thấy giá trị nhỏ nhất trong số lượng số lượng. Bây giờ xem lại

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90 và nghĩ về cách bạn mã hóa một hàm để tìm giá trị lớn nhất. Vâng, đó là nó! Bạn chỉ cần thay đổi toán tử so sánh từ nhỏ hơn (
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
36) và có thể đổi tên hàm và một số biến cục bộ để ngăn chặn sự nhầm lẫn.

Chức năng mới của bạn có thể trông giống như thế này:

>>>

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

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90. Hàm này giả định rằng
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4 không phải là trống và các giá trị của nó theo thứ tự tùy ý.

Hàm coi giá trị đầu tiên là một

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

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

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

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

>>> max("abcdWXYZ")
'd'
1 lặp lại phần còn lại của các phần tử trong dữ liệu đầu vào.

Tuyên bố có điều kiện so sánh

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại với
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 dự kiến ​​trong lần lặp đầu tiên. Nếu
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại nhỏ hơn
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92, thì các bản cập nhật có điều kiện
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

Mỗi lần lặp mới so sánh

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
94 hiện tại với
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
92 sẽ giữ giá trị nhỏ nhất trong dữ liệu đầu vào.

Mát mẻ! Bạn đã mã hóa một hàm tìm thấy giá trị nhỏ nhất trong số lượng số lượng. Bây giờ xem lại >>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 90 và nghĩ về cách bạn mã hóa một hàm để tìm giá trị lớn nhất. Vâng, đó là nó! Bạn chỉ cần thay đổi toán tử so sánh từ nhỏ hơn (>>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 35) thành lớn hơn (>>> min([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '<' not supported between instances of 'str' and 'int' >>> max([3, "5.0", 9, 1.0, "-5"]) Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' 36) và có thể đổi tên hàm và một số biến cục bộ để ngăn chặn sự nhầm lẫn.

Chức năng mới của bạn có thể trông giống như thế này:

Lưu ý rằng

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

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
90. Sự khác biệt quan trọng nhất, ngoài việc đặt tên, là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
06 sử dụng toán tử lớn hơn toán tử (
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
36) thay vì ít hơn toán tử (
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
06 tuân theo nguyên tắc khô (don Lặp lại). Bằng cách này, bạn sẽ sẵn sàng mô phỏng hành vi hoàn chỉnh của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 bằng cách sử dụng các kỹ năng Python của bạn, mà bạn sẽ giải quyết chỉ trong giây lát.

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("abcdefghijklmnopqrstuvwxyz")
'a'

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

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

>>> max("abcdWXYZ")
'd'
1 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 tùy chỉnh 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
3 và
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4, bạn 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(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
16
Cho phép bạn gọi chức năng với một số lượng khác hoặc bất kỳ số lượng đối số thông thườngYêu cầu

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

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

Cho phép bạn gọi chức năng với một số lượng khác hoặc bất kỳ số lượng đối số thông thường

Đúngoperator functions to find the minimum and maximum values, respectively. You’ll learn more about operator functions in a moment.

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

Giữ chức năng toán tử so sánh thích hợp để tính toán trong tay

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

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

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

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

Có chức năng đơn lẻ để sửa đổi chức năng so sánh tiêu chí và hành vi

Nếu

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 tăng
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04, thì bạn sẽ bắt nó và tự nâng
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04 của riêng bạn để thông báo cho người dùng rằng đối tượng được cung cấp không thể hiểu được, giống như
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 làm ở dạng tiêu chuẩn của họ. Lưu ý rằng bạn sử dụng cú pháp
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
44 để ẩn đi dấu vết của
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04 ban đầu.

Chi nhánh

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
46 chạy khi
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
35 chứa nhiều hơn một giá trị, xử lý các trường hợp người dùng gọi hàm với một số đối số thông thường thay vì với một giá trị có thể lặp lại.

Nếu điều kiện này cuối cùng không tăng

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

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04, thì
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
49 sẽ giữ một danh sách các giá trị có thể trống. Ngay cả khi danh sách kết quả trống rỗng, thì giờ đây, nó đã sạch sẽ và sẵn sàng để tiếp tục quá trình tìm kiếm giá trị tối thiểu hoặc tối đa của nó.

Xử lý đối số >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 4

Để tiếp tục viết

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25, bây giờ bạn có thể xử lý đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4. Đi trước và thêm mã sau vào cuối hàm:

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

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
49 có giữ một danh sách trống không. Nếu trường hợp đó, thì bạn sẽ kiểm tra đối số
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4 để xem người dùng có cung cấp giá trị cho nó không. Nếu
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4 vẫn là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
56, thì
>>> min("aA")
'A'

>>> max("aA")
'a'
5 được nâng lên. Nếu không,
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4 được trả lại. Hành vi này mô phỏng hành vi tiêu chuẩn của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 khi bạn gọi chúng bằng các vòng lặp trống.

Xử lý chức năng >>> min(3, 5, 9, 1, -5) -5 >>> max(3, 5, 9, 1, -5) 9 3 tùy chọn

Bây giờ bạn cần xử lý đối số

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

>>> max(3, 5, 9, 1, -5)
9
3 và chuẩn bị dữ liệu để tìm các giá trị nhỏ nhất và lớn nhất theo
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3 được cung cấp. Đi trước và cập nhật
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 với mã sau:

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

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

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

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

>>> max(3, 5, 9, 1, -5)
9
3. Nếu họ trú ẩn, thì bạn sẽ tạo một danh sách các khóa trực tiếp từ
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
49 ban đầu của bạn. Bạn sẽ sử dụng các khóa này làm khóa so sánh trong việc tính toán mức tối thiểu và tối đa.

Mặt khác, nếu người dùng đã cung cấp đối số

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

>>> max(3, 5, 9, 1, -5)
9
3, thì bạn cần đảm bảo rằng đối số thực sự là một hàm hoặc đối tượng có thể gọi được. Để làm điều này, bạn sử dụng hàm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
68 tích hợp, trả về
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
89 nếu đối số của nó là có thể gọi được và
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

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

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

>>> max(3, 5, 9, 1, -5)
9
3 là một đối tượng có thể gọi được, thì bạn sẽ xây dựng danh sách các khóa so sánh bằng cách áp dụng
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3 cho mỗi giá trị trong dữ liệu đầu vào.

Cuối cùng, nếu

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

>>> max(3, 5, 9, 1, -5)
9
3 không phải là một đối tượng có thể gọi được, thì mệnh đề
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
46 chạy, tăng
>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
04, giống như
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 làm trong một tình huống tương tự.

Tìm giá trị tối thiểu và tối đa

Bước cuối cùng để hoàn thành chức năng

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 của bạn là tìm các giá trị tối thiểu và tối đa trong dữ liệu đầu vào, giống như
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 làm. Đi trước và kết thúc
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 với mã sau:

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

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

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
83 thành giá trị đầu tiên trong
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
49, tương ứng. Các biến này sẽ cung cấp khóa và giá trị ban đầu để tính toán tối thiểu và tối đa.

Sau đó, bạn lặp qua các khóa và giá trị còn lại trong một lần sử dụng hàm

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
86 tích hợp. Hàm này sẽ mang lại các bộ dữ liệu giá trị khóa bằng cách kết hợp các giá trị trong danh sách
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
49 của bạn.

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22 để so sánh
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3 hiện tại với phím tối thiểu hoặc phím tối đa được lưu trữ trong
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
82. Tại thời điểm này, đối số
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22 sẽ giữ
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
94 từ mô -đun
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22, tùy thuộc vào việc bạn muốn tìm giá trị tối thiểu hoặc tối đa, tương ứng.

Ví dụ: khi bạn muốn tìm giá trị nhỏ nhất trong dữ liệu đầu vào,

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22 sẽ giữ hàm
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
93. Khi bạn muốn tìm giá trị lớn nhất,
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22 sẽ giữ
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Mỗi lần lặp vòng lặp đều so sánh

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

>>> max(3, 5, 9, 1, -5)
9
3 hiện tại với khóa tối thiểu hoặc tối đa dự kiến ​​và cập nhật các giá trị của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
83. Ở cuối vòng lặp, các biến này sẽ giữ khóa tối thiểu hoặc tối đa và giá trị tương ứng của nó. Cuối cùng, bạn chỉ cần trả về giá trị trong
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Mã hóa các chức năng tùy chỉnh min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 3 và min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 4 của bạn

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 tại chỗ, bạn có thể xác định các phiên bản tùy chỉnh của mình là
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4. Đi trước và thêm các chức năng sau vào cuối tệp
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
32 của bạn:

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
93 từ mô -đun
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
22. Các chức năng này tương đương chức năng của các toán tử lớn hơn (
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
35), tương ứng. Ví dụ: biểu thức boolean
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
37 tương đương với chức năng gọi
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
16. Bạn sẽ sử dụng các chức năng này để cung cấp đối số
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 của bạn.

Giống như

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

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

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

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

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

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

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

>>> max(3, 5, 9, 1, -5)
9
4 làm đối số và trả về các giá trị tối thiểu và tối đa, tương ứng. Để thực hiện tính toán, các chức năng này gọi
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
25 với các đối số cần thiết và với hàm so sánh thích hợp
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Trong

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

>>> max(3, 5, 9, 1, -5)
9
21, bạn sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
93 để tìm giá trị nhỏ nhất trong dữ liệu đầu vào. Trong
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
22, bạn sử dụng
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
94 để có được giá trị lớn nhất.

Nhấp vào phần Thu gọn bên dưới nếu bạn muốn lấy toàn bộ nội dung của tệp

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
32 của mình:

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trong Python. Bây giờ hãy tiếp tục và cho họ một thử!

Sự kết luận

Bây giờ bạn đã biết cách sử dụng các hàm

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 tích hợp của Python để tìm các giá trị nhỏ nhất và lớn nhất trong một loạt hoặc trong một loạt hai hoặc nhiều đối số thông thường. Bạn cũng đã tìm hiểu về một vài đặc điểm khác của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 có thể làm cho chúng hữu ích trong chương trình hàng ngày của bạn.smallest and largest values in an iterable or in a series of two or more regular arguments. You also learned about a few other characteristics of
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 that can make them useful in your day-to-day programming.

Trong hướng dẫn này, bạn đã học được cách:

  • Tìm các giá trị nhỏ nhất và lớn nhất bằng cách sử dụng Python từ
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4, tươ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
    
    3 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4, respectively
  • Gọi
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với một điề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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với chuỗi và từ điểnstrings and 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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4 với
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    3 và
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    4
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    3
    and
    >>> min(3, 5, 9, 1, -5)
    -5
    
    >>> max(3, 5, 9, 1, -5)
    9
    
    4
  • 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
    
    3 và
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4comprehensions and generator expressions into
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    3 and
    min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value
    
    max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
    
    4

Ngoài ra, bạn đã mã hóa một số ít các ví dụ thực tế bằng cách sử dụng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 để tiếp cận các vấn đề trong thế giới thực mà bạn có thể gặp phải trong khi mã hóa. Bạn cũng là một phiên bản tùy chỉnh bằng văn bản của
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trong Pure Python, một bài tập học tập đẹp giúp bạn hiểu logic đằng sau các chức năng tích hợp này.real-world problems that you might run into while coding. You’ve also a written custom version of
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

Max () là một phương thức hoặc hàm?

Vì Max () là một phương pháp toán học tĩnh, bạn luôn sử dụng nó như toán học.a static method of Math , you always use it as Math.

Max có phải là một phương pháp trong Python không?

Phương thức Python Max () Phương thức Max () trả về giá trị lớn nhất từ ​​các đối số có thể lặp lại hoặc nhiều đối số được chỉ định. The max() method returns the largest value from the specified iterable or multiple arguments.