search

Làm thế nào để bạn xác định số nào lớn hơn trong python?

Ngày đăng: 27/01/2023
Trả lời: 0
Lượt xem: 148

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 sẵn của Python rất hữu ích khi bạn cần tìm các giá trị nhỏ nhất và lớn nhất trong một hoặc trong một chuỗi các đối số thông thường. Mặc dù đây có vẻ như là những phép tính khá cơ bản, nhưng hóa ra chúng lại có nhiều trường hợp sử dụng thú vị trong lập trình thực tế. Bạn sẽ thử một số trường hợp sử dụng đó tại đây

Show

Trong hướng dẫn này, bạn sẽ học 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 của Python để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạn
  • Gọi 
    min(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 duy nhất hoặc với bất kỳ số lượng đối số thông thường nào
  • 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ển
  • Tinh 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
  • Sử dụng biểu thức hiểu 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
    4

Khi bạn đã nắm chắc kiến ​​thức này, thì bạn sẽ sẵn sàng viết một loạt các ví dụ thực tế thể hiện tính hữu dụng 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ẽ viết mã 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 bằng Python thuần túy, đ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 bên trong

Tiền thưởng miễn phí. 5 Suy nghĩ về Làm chủ Python, một khóa học miễn phí dành cho các nhà phát triển Python cho bạn thấy lộ trình và tư duy mà bạn sẽ cần để đưa các kỹ năng Python của mình lên một tầm cao mới

Để 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ư vòng lặp 

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

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

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

>>> max("abcdWXYZ")
'd'
1, hàm, hiểu danh sách và

Bắt đầu với 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 của Python

Python bao gồm một số chức năng tích hợp giúp 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 , 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ì?

Cho dù bạn đang sử dụng 

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

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

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

Loại bỏ các quảng cáo

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 duy nhất

Tích hợp sẵ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ó hai chữ ký khác nhau cho phép bạn gọi chúng bằng một đối số có thể lặp lại làm đối số đầu tiên của chúng hoặc bằng 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 trông giống như thế này

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

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

Cả hai hàm đều lấy một đối số bắt buộc có tên 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 có hai đối số 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

Ghi chú. Trong các chữ ký ở trên, dấu hoa thị (_______32_______7) có nghĩa là các đối số sau đây là các đối số chỉ chứa từ khóa, trong khi dấu ngoặc vuông (

>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
8) biểu thị rằng nội dung kèm theo là tùy chọn

Dưới đây là tóm tắt về những gì mà các đối số 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 làm

Đối sốMô tảBắt buộc_______32_______4Lấy một đối tượng có thể lặp lại, như danh sách, bộ dữ liệu, từ điển hoặc chuỗiCó

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

>>> max(3, 5, 9, 1, -5)
9
4Giữ giá trị để trả về nếu đầu vào có thể lặp lại trốngKhông
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3Chấp nhận hàm một đối số để tùy chỉnh tiêu chí so sánhKhông

Ở phần sau của hướng dẫn này, bạn sẽ tìm hiểu thêm về các đối số 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. 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à đối số bắt buộc thúc đẩy 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

>>> 

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

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

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

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

Trong những ví dụ này, bạn gọi 

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

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

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

>>> max("aA")
'a'
2. Ngược lại, cuộc gọi đầu tiên đến ____0_______4 trả về số lớn nhất trong danh sách hoặc ____51_______4. Nếu bạn chuyển một iterator trống cho 
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, thì bạn sẽ nhận được một 
>>> min("aA")
'A'

>>> max("aA")
'a'
7 vì không có gì để làm trên một iterable trống

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

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

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

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

>>> 

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

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

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

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

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

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
00 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
01 trong các cuộc gọi tớ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 nhận được kết quả như mong đợi trong cả hai trường hợp vì các loại dữ liệu này có thể so sánh được

Tuy nhiên, điều gì sẽ xảy ra nếu bạn trộn lẫn chuỗi và số?

>>> 

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

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

Bạn không 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 một loại có thể lặp lại không thể so sánh làm đối số. Trong ví dụ này, một hàm cố gắng so sánh một số với một chuỗi, giống như so sánh táo và cam. Kết quả cuối cùng là 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
06

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 chúng với bất kỳ số đối số nào, miễn là bạn sử dụng ít nhất hai đối số. Chữ ký này có dạng như 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 là ý nghĩa của các đối số trong chữ ký trên

Đối số Mô tảBắt buộc_______47_______11Chấp nhận bất kỳ số lượng đối số thông thường nào để so sánhCó (ít nhất hai trong số chúng)

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

>>> max(3, 5, 9, 1, -5)
9
3Nhận hàm một đối số để tùy chỉnh 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 lệnh gọi để hàm 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 là không bắt buộc, bởi vì bạn sẽ luôn có ít nhất hai giá trị để so sánh nhằm tìm giá trị 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 đối số thông thường trở lên. Một lần nữa, bạn sẽ nhận được giá trị tối thiểu hoặc tối đa tương ứng trong dữ liệu đầu vào. Điều kiện duy nhất là các đối số phải được so sánh

Loại bỏ các quảng cáo

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 Strings và Iterables of Strings

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 được. Mặt khác, 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
06, 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 dưới dạng 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 hữu ích và phổ biến nhất của các hàm này. Tuy nhiên, bạn cũng có thể sử dụng các hàm với chuỗi và các lần lặp của chuỗi. Trong những trường hợp này, thứ tự 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 ngữ cảnh này, nhỏ nhất có nghĩa là gần đầu bảng chữ cái nhất và lớn nhất có nghĩa là gần cuối bảng chữ cái nhất

>>> 

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

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

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

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

Như đã hứa, trong hai ví dụ đầu tiên, 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 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
29 và 
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
31. Tuy nhiên, trong cặp ví dụ thứ hai, 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 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
33 và 
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
35. Tại sao?

Ghi chú. Python xử lý nội bộ các chuỗi dưới dạng các ký tự có thể lặp lại. Vì vậy, 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 một chuỗi làm đối số giống như gọi hàm với một lần lặp của các ký tự riêng lẻ

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 một chuỗi làm đối số không chỉ giới hạn ở các chữ cái. Bạn có thể sử dụng các chuỗi chứa bất kỳ ký tự nào có thể có trong bộ ký tự hiện tại của mình. Ví dụ: nếu bạn chỉ làm việc với tập hợp các ký tự ASCII, thì ký tự nhỏ nhất là ký tự gần đầu của ký tự nhất. Ngược lại, ký tự lớn nhất là ký tự gần cuối bảng nhất

Với các bộ ký tự khác như UTF-8, 

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 hoạt động tương tự

>>> 

>>> # UTF-8 characters

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

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

Đằng sau hậu trườ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 sử dụng giá trị số của ký tự để tìm các ký tự tối thiểu và tối đa trong chuỗi đầu vào. Ví dụ, trong bảng ký tự Unicode, chữ hoa 
>>> 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 có giá trị số nhỏ hơn 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
45

>>> 

>>> ord("A")
65

>>> ord("a")
97

Hàm tích hợp sẵn của Python nhận một ký tự Unicode và trả về một số nguyên biểu thị điểm mã Unicode của ký tự đó. Trong các ví dụ này, điểm mã cho chữ hoa 

>>> 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
47 thấp hơn điểm mã cho 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
48

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
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ả hai chữ cái, bạn sẽ nhận được kết quả khớp với thứ tự của các điểm mã Unicode cơ bản của những chữ cái này

>>> 

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

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

Điều gì làm cho 

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

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

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
47 nhỏ 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
48? . Tất cả các ký tự mà bạn có thể gõ trên bàn phím và nhiều ký tự khác đều có điểm mã riêng trong bảng Unicode. Python sử dụng các điểm mã này để xác định ký tự tối thiểu và tối đa khi sử dụng 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

>>> 

>>> min([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

Để tìm chuỗi nhỏ nhất hoặc lớn nhất trong một chuỗi có thể lặp lại, 

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

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

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

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

>>> min([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
59 xuất hiện trướ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
60, 
>>> 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
48 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
62 trong bảng Unicode. Vì vậy, 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 ngay lập tức kết luận rằ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
64 là chuỗi nhỏ nhất. Trong ví dụ thứ hai, 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
62 xuất hiện sau tất cả các chữ cái đầu tiên của các chuỗi khác

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
62, 
>>> 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 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
68. Vì vậy, Python tiến hành xem xét 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
68 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
71 đế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
72

Loại bỏ các quảng cáo

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 cân nhắc rằng nếu bạn sử dụng từ điển trực tiếp thì cả hai chức năng sẽ hoạt động trên các phím

>>> 

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

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

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
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ự bảng 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
78 và 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về khóa lớn nhất. Bạn có thể nhận được kết quả tương tự bằng cách sử dụng phương pháp 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

Sự khác biệt duy nhất giữa ví dụ sau này và ví dụ trước là ở đây, mã rõ ràng hơn về những gì bạn đang làm. Bất kỳ 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 nhập liệu

Một yêu cầu phổ biến khác 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ụ 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
78, 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

>>> ______47_______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 duyệt 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
78 và tìm 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
78 và trả về giá tối đa

Cuối cùng, bạn cũng có thể sử dụng phương pháp trên từ điển đầu vào để tìm các cặp khóa-giá trị tối thiểu và tối đ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
4

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 các bộ dữ liệu theo 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
90 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
91 hay không), Python kiểm tra 
>>> min([3, 5, 9, 1, -5])
-5

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

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

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence
92. 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
93, thì Python kết luận rằng bộ thứ nhất lớn hơn bộ thứ hai mà không cần kiểm tra các mục còn lại. 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
94, thì Python kết luận rằng bộ thứ nhất nhỏ hơn bộ thứ hai

Cuối cùng, 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
95, thì Python sẽ so sánh cặp mục thứ hai bằng cách sử dụng cùng một quy tắc. Lưu ý rằng trong ngữ cảnh này, mục đầu tiên của mỗi bộ dữ liệu đến từ các khóa từ điển và vì các khóa từ điển là duy nhất nên các mục không thể bằng nhau. Vì vậy, Python sẽ không bao giờ phải so sánh các giá trị thứ hai

Tinh chỉnh Hành vi Tiêu chuẩn của min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 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

Cho đến thời điểm này, bạn đã học được cách thức hoạt động 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 ở dạng chuẩn của chúng. Trong phần này, bạn sẽ học cách điều chỉnh hành vi tiêu chuẩn của cả hai hàm bằng cách sử dụng các đối số chỉ từ khóa 
>>> 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

Đối số 

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

>>> max(3, 5, 9, 1, -5)
9
3 cho 
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 cho phép bạn cung cấp hàm một đối số sẽ được áp dụng cho mọi giá trị trong dữ liệu đầu vào. Mục tiêu là sửa đổi các tiêu chí so sánh để sử dụng trong việc tìm giá trị tối thiểu hoặc tối đa

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

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

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

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

>>> 

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

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

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

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

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

Trong trường hợp đó, giải pháp là chuyển hàm tích hợp dưới dạng đối số 

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

>>> max(3, 5, 9, 1, -5)
9
3 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, như trong các ví dụ sau

>>> 

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

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

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

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

Tuyệt vời. Bây giờ, kết quả của 

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 phụ thuộc vào các giá trị số của các chuỗi bên dưới. Lưu ý rằng bạn không cần gọi 
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
09. Bạn chỉ cần vượt qua 
>>> 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
00 mà không cần cặp dấu ngoặc đơn vì 
>>> min(3, 5, 9, 1, -5)
-5

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

Ghi chú. Các đối tượng có thể gọi được trong Python bao gồm các hàm, phương thức, lớp và thể hiện của bất kỳ lớp nào cung cấp một

Đối số chỉ dành cho từ khóa thứ hai cho phép bạn tùy chỉnh hành vi tiêu chuẩn của 

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

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

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

>>> max(3, 5, 9, 1, -5)
9
4. Hãy nhớ rằng đối số này chỉ khả dụng khi bạn gọi hàm với một lần lặp duy nhất làm đối số

Công việc của 

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 khi nó được gọi với một iterable trố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
7

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 để nêu lên một 
>>> min("aA")
'A'

>>> max("aA")
'a'
7 phàn nàn về đối số chuỗi trống. Tuy nhiên, vì bạn cung cấp một giá trị cho 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4, cả hai hàm hiện trả về giá trị này thay vì đưa ra một ngoại lệ và phá vỡ mã của bạn

Loại bỏ các quảng cáo

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 phần hiểu và biểu thức 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 cách hiểu danh sách hoặc dưới dạng đối số. Tính năng này rất hữu ích khi bạn cần chuyển đổi dữ liệu đầu vào ngay trước khi tìm giá trị được chuyển đổi tối thiểu hoặc tối đa

Khi bạn cung cấp khả năng hiểu danh sách 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 việc hiểu danh sách làm đối số. Cách hiểu 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
36 bằng cách áp dụng phương pháp 
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
37 cho từng 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
48, không có trong dữ liệu gốc. Điều gì đó tương tự cũng xảy ra với các ví dụ về 
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 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 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 cũng 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 khả năng hiểu, 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
37 để sửa đổi tiêu chí so sánh bằng cách nào đó. Sự khác biệt là khả năng hiểu thực sự biến đổi dữ liệu đầu vào trước khi thực hiện tính toán, vì vậy giá trị kết quả đến từ dữ liệu đã chuyển đổi chứ không phải từ dữ liệu gốc

Khả năng hiểu danh sách tạo ra một danh sách đầy đủ trong bộ nhớ, đây thường là một thao tác 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 mình nữa, đó có thể là trường hợp 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ì vậy, thay vào đó, việc sử dụng biểu thức trình tạo luôn hiệu quả hơn

Cú pháp cho các biểu thức trình tạo gần giống như đối với việc hiểu danh sách

>>> 

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

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

Sự khác biệt chính về cú pháp là biểu thức trình tạo sử dụng dấu ngoặc đơn thay vì dấu ngoặc vuông (

>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
8). Bởi vì lệnh gọi hàm đã yêu cầu dấu ngoặc đơn, bạn chỉ cần xóa dấu ngoặc vuông khỏi các ví dụ dựa trên khả năng hiểu của mình và bạn đã sẵn sàng. Không giống như khả năng hiểu danh sách, các biểu thức trình tạo tạo ra các mục theo yêu cầu, điều này làm cho chúng trở nên hiệu quả về bộ nhớ

Đư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ủa Python vào hoạt động

Cho đến giờ, bạn đã học được những kiến ​​thức cơ bản về 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 để tìm các giá trị nhỏ nhất và lớn nhất trong một lần lặp hoặc trong một chuỗi các giá trị riêng lẻ. Bạn đã học cách 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

Bây giờ bạn đã sẵn sàng để bắt đầu viết mã một vài ví dụ thực tế sẽ chỉ cho bạn cách sử dụng 

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

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

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

Xóa các số nhỏ nhất và lớn nhất trong danh sách

Để bắt đầu, bạn sẽ bắt đầu với một ví dụ ngắn về cách xóa giá trị tối thiểu và tối đa khỏi danh sách số. Để làm điều đó, bạn có thể gọi 

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

>>> max([3, 5.0, 9, 1.0, -5])
9
57 trong danh sách đầu vào của mình. Tùy thuộc vào nhu cầu của bạn, bạn sẽ sử dụng 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

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

>>> 

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

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

Trong các ví dụ này, các giá trị tối thiểu và tối đa trong 

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

>>> max([3, 5.0, 9, 1.0, -5])
9
60 có thể là các điểm dữ liệu ngoại lệ mà bạn muốn xóa để chúng không ảnh hưởng đến phân tích tiếp theo của bạn. Ở đây, 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 cung cấp các lập luận cho 
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

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

Bây giờ, giả sử rằng bạn có một danh sách gồm các danh sách biểu thị một ma trận các giá trị số và bạn cần xây dựng các danh sách chứa các giá trị nhỏ nhất và lớn nhất từ ​​mỗi hàng trong ma trận đầu vào. Để làm điều này, bạn có thể sử dụng 

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 cùng với khả năng hiểu danh sách

>>> 

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

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

Cách hiểu đầu tiên lặp lại các danh sách con trong 

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 để tạo danh sách chứa giá trị nhỏ nhất từ ​​mỗi danh sách con. Cách hiểu thứ hai thực hiện nhiệm vụ tương tự nhưng sử dụng 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 để tạo danh sách chứa các giá trị lớn nhất từ ​​các danh sách con trong 
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

Mặc dù 

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 cung cấp một cách nhanh chóng để xử lý các ví dụ trong phần này, thư viện NumPy rất được khuyến khích khi xử lý ma trận trong Python vì NumPy có các công cụ cụ thể và được tối ưu hóa cho công việc

Loại bỏ các quảng cáo

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

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

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

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

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? . 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 theo 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 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 bớt cho 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
76 và 
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

>>> max([3, 5.0, 9, 1.0, -5])
9
78, là giới hạn trên của khoảng

Ngược lại, nếu bạn muốn cắt các giá trị nhỏ xuống giới hạn dưới của khoảng, 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ày đến 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 cắt các giá trị nhỏ thành giới hạn dưới của khoảng thời gian. Để thực hiện thao tá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 của khoảng để tìm giá trị lớn nhất. Trong ví dụ, 
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
82 là số duy nhất bị cắt bớt

Cuối cùng, bạn có thể chạy cả hai hoạt động 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 thực hiện

>>> 

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

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

Để cắt tất cả các giá trị nằm ngoài giới hạn của khoảng, cách hiểu 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. Lệnh gọi tới 
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, trong khi lệnh gọi tới 
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 dưới. 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 bớt theo chính giới hạn đó

Cách hiểu 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
89 từ NumPy, lấy một mảng và các giới hạn của khoảng mục tiêu, sau đó nó cắt tất cả các giá trị bên ngoài khoảng vào các cạnh của khoảng

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

Bây giờ giả sử rằng bạn có một danh sách các bộ chứa các cặp giá trị đại diện cho các điểm Descartes. 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 điều gì đó như sau

>>> 

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

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

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
90 để có quyền truy cập vào. Hàm này trả về khoảng cách Euclide giữa hai điểm p và q, mỗi điểm được cho dưới dạng một chuỗi tọa độ. Hai điểm phải có cùng số chiều

Hàm 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 thực hiện 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 nhận một hàm 
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
95 tính khoảng cách giữa hai điểm. Hàm này trở thành tiêu chí so sánh để 
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 có khoảng cách giữa các điểm là nhỏ nhất

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

>>> max(3, 5, 9, 1, -5)
9
3 cần một hàm một đối số, trong khi 
>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9
99 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
95 nhận một đối số duy nhất, 
>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
01, sau đó giải nén nó thành hai đối số để nạp vào 
>>> min([3, 5.0, 9, 1.0, -5])
-5

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

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

Bây giờ, giả sử 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 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 hàm 

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

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

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

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

>>> max([3, 5.0, 9, 1.0, -5])
9
95 thích hợp làm đối số 
>>> min(3, 5, 9, 1, -5)
-5

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

>>> 

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

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

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
95 lấy một cặp khóa-giá trị làm đối số và trả về giá trị tương ứng sao 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 có tiêu chí so sánh phù hợp. Kết quả là bạn nhận được một bộ dữ liệu có sản phẩm rẻ nhất và đắt nhất trong dữ liệu đầu vào

Loại bỏ các quảng cáo

Tìm số nguyên tố cùng nhau

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 một bài toán trong thế giới thực là khi bạn cần tìm hiểu xem hai số có nguyên tố cùng nhau hay không. Nói cách khác, bạn cần biết liệu ước số chung duy nhất của các số của bạn có phải 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'
10 hay không

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

>>> 

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

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

Trong đoạn mã này, bạn định nghĩ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'
11 là một hàm vị ngữ 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
93 nếu các số đầu vào là nguyên tố cùng nhau. Nếu các số không nguyên tố cùng nhau, thì hàm trả 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'
13

Thành phần chính của hàm là một vòng lặp 

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

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

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

>>> max("abcdWXYZ")
'd'
1 lặp lại trên 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'
15 giá trị. Để đặt giới hạn trên cho đố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'
15 này, bạn sử dụng 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 với các số đầu vào làm đối số. Một lần nữa, bạn đang sử dụng 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 để đặt giới hạn trên của một khoảng thời gian nào đó

Thời gian thực hiện khác nhau của mã của bạn

Bạn cũng có thể sử dụng 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 để so sánh một số thuật toán của mình, đánh giá thời gian thực hiện của chúng và xác định thuật toán nào hiệu quả nhất. Ví dụ dưới đây sử dụng để đo thời gian thực hiện cho hai cách khác nhau để tạo danh sách chứa các giá trị bình phương của các số 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'
21 đế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'
22

>>> 

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

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

Cuộc gọi đến ____64_______20 chạy một câu lệnh dựa trên chuỗi một số lần nhất định. Trong những ví dụ này, tuyên bố được lặp lại ba lần. Lệnh gọi tới 

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'
26 và các hàm hẹn giờ khác của Python, bạn có thể biết được thuật toán nào hiệu quả nhất về mặt thời gian thực hiện. Ví dụ trên cho thấy rằng khả năng hiểu 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'
27 tích hợp khi xây dựng 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' 28 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' 29 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 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 đủ linh hoạt để hoạt động với các giá trị thuộc nhiều loại dữ liệu khác nhau, chẳng hạn như số và chuỗi. Bí mật đằng sau sự 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 áp dụng triết lý gõ vịt của Python bằng cách dựa vào các phương thức đặc biệt và

Các phương thức này là một phần của cái mà Python gọi là các phương thức 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'
28 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'
29 tương ứng 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'
40) 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'
41). Ý nghĩa của hỗ trợ ở đây là gì?

Điều rút ra 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'
28 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'
29. Đó là lý do tại sao các hàm này hoạt động với các giá trị của tất cả các kiểu dữ liệu tích hợp sẵn 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 kiểu dữ liệu có sẵn của Python triển khai các phương thức đặ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'
28 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'
29. 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 được

Bạn cũng có thể làm cho các thể hiệ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 mình 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'
28 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'
29. Hãy 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'
56 sau đây làm 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'
28 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'
29 yêu cầu một đối số 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'
59. Đố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'
42, bạn sẽ có ____64_______61 sẽ là ____64_______62 và _____64_______63 sẽ là ____64_______59

Ghi chú. Để các hoạt động so sánh nhỏ hơn và lớn hơn hoạt động bình thường, bạn chỉ cần 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'
28 hoặ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'
29

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'
28 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'
29 trả về kết quả so sánh các thuộc tí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'
69 của hai người. Đây là cách nó hoạt động 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 lạnh. 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'
56 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 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'
28 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'
29. Cuộc gọi tới 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
3 trả về người nhỏ tuổi nhất và cuộc gọi tới 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
4 trả về người lớn tuổi nhất

Ghi chú. Các phương pháp 

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

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'
28 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'
29 chỉ cung cấp hỗ trợ cho hai toán tử 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'
40 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'
41. Nếu bạn muốn một lớp cung cấp tất cả các thao tác so sánh, nhưng bạn chỉ muốn viết một vài phương thức đặc biệt, thì bạn có thể sử dụng. Nếu bạn có một lớp định nghĩ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'
82 và các phương thức so sánh phong phú khác, thì trình trang trí này sẽ tự động cung cấp các phương thức so sánh còn lại

Lưu ý rằng nếu một lớp tùy chỉnh nhất định không cung cấp các phương thức này, thì các thể hiện của nó sẽ không hỗ trợ các hoạt độ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

>>> 

>>> 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'
85 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'
28 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'
29, nê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 trả lời bằng một câu trả lờ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
06. Thông báo lỗi cho bạn biết rằng các hoạt động so sánh không được hỗ trợ trong lớp hiện tại của bạn

Loại bỏ các quảng cáo

Giả lậ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 của Python

Cho đến thời điểm này, bạn đã học được cách hoạt động của 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 của Python. 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ố, chuỗi, v.v. Bạn biết cách gọi các hàm này bằng một lần lặp duy nhất làm đối số hoặc với 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 giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạn, 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ẽ tìm hiểu cách tìm giá trị tối thiểu và tối đa trong dữ liệu của mình. Bạn cũng sẽ học cách triển khai 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

Hiểu Quy tắc Đằ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ị nhỏ nhất trong một danh sách nhỏ các số với tư cách là con người, thông thường bạn sẽ kiểm tra các số và ngầm so sánh tất cả chúng trong đầu. 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 như vậy. Họ cần hướng dẫn chi tiết để hoàn thành bất kỳ nhiệm vụ nào

Bạn sẽ phải yêu cầu 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 từng cặp. Trong quá trình này, máy tính phải lưu ý 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

Lời giải thích này có thể khó hình dung, vì vậy đây là một hàm 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(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
03. Hàm này giả định rằng 
>>> # UTF-8 characters

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

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

Hàm coi giá trị đầu tiên là giá trị dự kiến ​​

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05. Sau đó, vòng lặp 
>>> min("abcdefghijklmnopqrstuvwxyz")
'a'

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

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

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

Câu lệnh điều kiện so sánh 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
07 hiện tại với 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05 dự kiến ​​trong lần lặp đầu tiên. Nếu 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
07 hiện tại nhỏ hơn 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05, thì các bản cập nhật có điều kiện của 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05 tương ứng

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
07 hiện tại với 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05 được cập nhật. Khi hàm chạy đến cuối 
>>> # UTF-8 characters

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

>>> max("abc123ñ")
'ñ'
4, thì 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
05 sẽ giữ giá trị nhỏ nhất trong dữ liệu đầu vào

Mát lạnh. Bạn đã mã hóa một hàm tìm giá trị nhỏ nhất trong một số có thể lặp lại. Bây giờ hãy xem lại 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
03 và nghĩ xem bạn sẽ viết mã một hàm như thế nào để tìm giá trị lớn nhất. Vâng, đó là nó. Bạn chỉ cần thay đổi 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'
40) 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'
41), và có thể đổi tên hàm và một số để tránh 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

Lưu ý rằng 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
19 chia sẻ hầu hết mã của nó với 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
03. 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
19 sử dụng 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'
41) thay vì 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'
40)

Như một bài tập, bạn có thể nghĩ về cách tránh mã lặp lại trong 

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
19 theo nguyên tắc DRY (không lặp lại chính mình). Bằng cách này, bạn sẽ sẵn sàng mô phỏng toàn bộ 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 bằng các kỹ năng Python của mình, bạn sẽ giải quyết vấn đề này chỉ trong giây lát

Trước khi đi sâu vào, bạn cần lưu ý các yêu cầu về kiến ​​thức. Bạn sẽ kết hợp các chủ đề như câu lệnh có điều kiện, xử lý ngoại lệ, hiểu danh sách, phép lặp xác định với vòng lặp 

>>> 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
29 và các đối số tùy chọn trong hàm

Nếu bạn cảm thấy rằng bạn không biết mọi thứ về những chủ đề này, thì đừng lo lắng. Bạn sẽ học bằng cách làm. Nếu bạn gặp khó khăn, thì bạn có thể quay lại và xem lại các tài nguyên được liên kết

Loại bỏ các quảng cáo

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 

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 viết mã một hàm trợ giúp 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 lệnh 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

Hàm trợ giúp của bạn sẽ có chữ ký 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'
6

Đây là những gì mỗi đối số làm

Đối sốMô tảBắt buộc_______0_______29Cho phép bạn gọi hàm với một đối số có thể lặp lại hoặc bất kỳ số lượng đối số thông thường nào Có

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
35Giữ hàm toán tử so sánh thích hợp cho phép tính trong tayCó
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
3Nhận hàm một đối số sửa đổi tiêu chí và hành vi so sánh của hàmKhông
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4Lưu trữ một giá trị mặc định để trả về khi bạn gọi hàm với

Phần thân của 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 sẽ bắt đầu bằng cách xử lý 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
29 để tạo danh sách các giá trị. Có một danh sách các giá trị được tiêu chuẩn hóa sẽ cho phép bạn viết thuật toán cần thiết để tìm các giá trị tối thiểu và tối đa trong dữ liệu đầu vào

Sau đó, hàm cần xử lý 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 trước khi tính giá trị tối thiểu và tối đa, đây là bước cuối cùng bên trong 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Với 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 tại chỗ, bước cuối cùng là xác định hai chức năng độc lập trên nó. Các hàm này sẽ sử dụng các hàm toán tử so sánh thích hợp để tìm các giá trị nhỏ nhất và lớn nhất tương ứng. Bạn sẽ tìm hiểu thêm về các hàm toán tử trong giây lát

Chuẩn hóa dữ liệu đầu vào từ min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value 29

Để chuẩn hóa dữ liệu đầu vào, bạn cần kiểm tra xem người dùng đang cung cấp một đối số có thể lặp lại hay bất kỳ đối số thông thường nào. Kích hoạt trình soạn thảo mã hoặc IDE yêu thích của bạn và tạo một tệp Python mới có tên là 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
45. Sau đó thêm đoạn mã sau vào 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'
7

Ở đây, bạn xác định 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38. Phần đầu tiên của chức năng chuẩn hóa dữ liệu đầu vào để xử lý thêm. Bởi vì người dùng sẽ có thể gọi 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 với một lần lặp duy nhất hoặc với một số đối số thông thường, bạn cần kiểm tra độ dài của 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
48. Để thực hiện việc kiểm tra 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
49 tích hợp sẵn

Nếu 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
48 chỉ giữ một giá trị, thì bạn cần kiểm tra xem đối số đó có phải là một đối tượng có thể lặp lại không. Bạn sử dụng , điều này hoàn toàn thực hiện kiểm tra và cũng biến đầu vào có thể lặp lại thành một danh sách

Nếu 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
51 tăng 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
06, thì bạn nắm bắt nó và 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
06 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ể lặp lại, 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 chúng. 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
57 để ẩn truy nguyên của bản 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
06

Nhánh 

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

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

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
62 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, nó hiện đã sạch và sẵn sàng để tiếp tục quá trình tì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
38, 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. Hãy tiếp tục và thêm đoạn 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
62 có chứa danh sách trống không. Nếu đúng như vậy, thì bạn kiểm tra đối số 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
4 để xem liệu người dùng có cung cấp giá trị cho đối số đó không. Nếu _______10_______4 vẫn là _______0_______69, thì _______51_______7 được nâng lên. Mặt khác, 
>>> 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 với các lần lặp trống

Loại bỏ các quảng cáo

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. Hãy tiếp tụ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
38 với đoạn 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 chưa cung cấp hàm 

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

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

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

Mặt khác, nếu người dùng đã cung cấp một đố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. Để thực hiện việc này, bạn sử dụng hàm 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
93 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'
13 nếu không

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

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

>>> max(3, 5, 9, 1, -5)
9
3 là một đối tượng có thể gọi được, thì bạn 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 từng 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
59 sẽ chạy, tạo ra 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
06, giống như ___________3 và ___________4 trong tình huống tương tự

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

Bước cuối cùng để hoàn thành hàm 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 của bạn là tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu đầu vào, giống như cách làm 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. Tiếp tụ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
38 với đoạn 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
95 và 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
62, tương ứng. Các biến này sẽ cung cấp khóa và giá trị ban đầu để tính giá trị tối thiểu và tối đa

Sau đó, bạn lặp lại các khóa và giá trị còn lại trong một lần bằng cách 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
99 tích hợp. Hàm này sẽ tạo ra các bộ khóa-giá trị 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
97 và 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

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

Đ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
35 để 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 ​​đượ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
95. 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
35 sẽ giữ hoặc là 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
06 hoặc là 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
07 từ mô-đun 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
35, tùy thuộc vào việc bạn muốn tìm giá trị nhỏ nhất hay lớn nhất tương ứng

Ví dụ khi bạn muốn tìm giá trị nhỏ nhất trong dữ liệu nhập vào thì hàm 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
35 sẽ giữ hàm 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
06. 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
35 sẽ giữ 
>>> min(3, 5, 9, 1, -5)
-5

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

Mỗi lần lặp lại vòng lặp 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
95 và 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
96 tương ứng. Ở 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
96

Mã hóa 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ùy chỉnh 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
38, bạn có thể xác định các phiên bản tùy chỉnh của mình 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. Hãy tiếp tụ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
45 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 và từ mô-đun 

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
35. Các hàm này tương đương với 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'
41) 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'
40), 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'
42 tương đương với lệnh gọi hàm 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
29. Bạn sẽ sử dụng các hàm 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
35 cho 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 của mình

Cũng 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
34 và 
>>> min(3, 5, 9, 1, -5)
-5

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

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
29, 
>>> 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ề giá trị tối thiểu và tối đa tương ứng. Để thực hiện phép tính, các hàm này gọi hàm 
min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value
38 với các đối số bắt buộc và 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
35

Trong 

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

>>> max(3, 5, 9, 1, -5)
9
34, bạn sử dụng 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
06 để 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
35, bạn sử dụng 
>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9
07 để nhận giá trị lớn nhất

Nhấp vào phần có thể 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
45 của mình

Mã nguồn hoàn chỉnhHiển thị/Ẩn

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

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

Mát lạnh. Bạn đã hoàn thành 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 bằng Python. Bây giờ hãy tiếp tục và thử chúng

Loại bỏ các quảng cáo

Phần 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 sẵn của Python để tìm các giá trị nhỏ nhất và lớn nhất trong một lần lặp hoặc trong một chuỗi gồm hai đối số thông thường trở lên. Bạn cũng đã học về một số đặ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ể giúp chúng hữu ích trong việc lập trình hàng ngày của bạn

Trong hướng dẫn này, bạn đã họ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's 
    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 ứng
  • 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 duy nhất và với một số đố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 chuỗi và từ điển
  • 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
  • Khả năng hiểu nguồn cấp dữ liệu và biểu thức trình tạo thà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

Ngoài ra, bạn đã viết mã một số 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 khi viết mã. Bạn cũng có 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 bằng Python thuần túy, một bài tập học tập thú vị giúp bạn hiểu logic đằng sau các hàm tích hợp sẵn này

Tiền thưởng miễn phí. 5 Suy nghĩ về Làm chủ Python, một khóa học miễn phí dành cho các nhà phát triển Python cho bạn thấy lộ trình và tư duy mà bạn sẽ cần để đưa các kỹ năng Python của mình lên một tầm cao mới

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Làm thế nào để bạn xác định số nào lớn hơn trong python?

Gửi cho tôi thủ thuật Python »

Giới thiệu về Leodanis Pozo Ramos

Làm thế nào để bạn xác định số nào lớn hơn trong python?
Làm thế nào để bạn xác định số nào lớn hơn trong python?

Leodanis là một kỹ sư công nghiệp yêu thích Python và phát triển phần mềm. Anh ấy là một nhà phát triển Python tự học với hơn 6 năm kinh nghiệm. Anh ấy là một nhà văn đam mê kỹ thuật với số lượng bài báo được xuất bản ngày càng tăng trên Real Python và các trang web khác

» Tìm hiểu thêm về Leodanis

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Làm thế nào để bạn xác định số nào lớn hơn trong python?

Aldren

Làm thế nào để bạn xác định số nào lớn hơn trong python?

Geir Arne

Làm thế nào để bạn xác định số nào lớn hơn trong python?

kate

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Chuyên gia Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Mã Python nào lớn hơn?

Chương trình Python . ')) b = int(input('Nhập số thứ hai. ')) c = int(input('Nhập số thứ ba. ')) lớn nhất = 0 nếu a > b và a > c. lớn nhất = a nếu b > a và b > c. lớn nhất = b nếu c > a và c > b. lớn nhất = c print(lớn nhất, "là số lớn nhất trong ba số. ")

Làm cách nào để tìm số lớn nhất trong ba số bằng Python?

Bước 1. nhập ba số đầu vào của người dùng. Bước 2. Thêm ba số vào danh sách. Bước 3. Dùng hàm max() để tìm số lớn nhất max(lst) . Bước 4. Và cuối cùng chúng tôi sẽ in số lượng tối đa.

programming python

Bài Viết Liên Quan

Bao cáo đầu tư mua đất để làm văn phòng năm 2024
Bao cáo đầu tư mua đất để làm văn phòng năm 2024

mẹo hay
Anh bộ đội cụ hồ gốc bỉ là gì năm 2024
Anh bộ đội cụ hồ gốc bỉ là gì năm 2024

là ai Hỏi Đáp Là gì
Tìm hiểu chung về văn bản nghị luận năm 2024
Tìm hiểu chung về văn bản nghị luận năm 2024

mẹo hay
Sử lý lỗi không lăng được chuột trong sketchup năm 2024
Sử lý lỗi không lăng được chuột trong sketchup năm 2024

mẹo hay Công Nghệ Chuột
Bài tập tìm hằng số cân bằng hoá 11 năm 2024
Bài tập tìm hằng số cân bằng hoá 11 năm 2024

mẹo hay Khỏe Đẹp Bài tập
Băn khoăn có nghĩa là gì năm 2024
Băn khoăn có nghĩa là gì năm 2024

là ai Hỏi Đáp Là gì Ngôn ngữ Nghĩa là gì
Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024
Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024

mẹo hay
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Bánh
Họ tiếng nhật của bạn là gì năm 2024
Họ tiếng nhật của bạn là gì năm 2024

là ai Hỏi Đáp Là gì
Ý nghĩa của header from top là gì năm 2024
Ý nghĩa của header from top là gì năm 2024

mẹo hay Hỏi Đáp Là gì Top List Top Header la gì Footer la gì
Tự học tiếng anh như thế nào hiệu quả năm 2024
Tự học tiếng anh như thế nào hiệu quả năm 2024

mẹo hay Hỏi Đáp Thế nào Học Tốt Học Tiếng anh Học tiếng Anh
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Khỏe Đẹp Cơ thể
Tuổi đinh mão xây nhà năm nào tốt năm 2024
Tuổi đinh mão xây nhà năm nào tốt năm 2024

mẹo hay Xây Đựng Xây Nhà
Khoán chi đến sản phẩm cuối cùng là gì năm 2024
Khoán chi đến sản phẩm cuối cùng là gì năm 2024

là ai Hỏi Đáp Là gì
Các yếu tố cấu thành văn hóa tổ chức năm 2024
Các yếu tố cấu thành văn hóa tổ chức năm 2024

mẹo hay
Thế nào là số vô tỉ cho ví dụ năm 2024
Thế nào là số vô tỉ cho ví dụ năm 2024

mẹo hay Hỏi Đáp Thế nào Ví dụ
Quà trung thu tiếng anh là gì năm 2024
Quà trung thu tiếng anh là gì năm 2024

là ai Hỏi Đáp Là gì Học Tốt Tiếng anh Mid-Autumn gift
Đẻ mổ tối đa được bao nhiêu lần năm 2024
Đẻ mổ tối đa được bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu
Thiết kế quán trà sữa bao nhiêu tiền năm 2024
Thiết kế quán trà sữa bao nhiêu tiền năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Trà sữa
Top nước hoa hồng se khít lỗ chân lông năm 2024
Top nước hoa hồng se khít lỗ chân lông năm 2024

mẹo hay Top List Top

Quảng Cáo

Có thể bạn quan tâm

Bài tập giới hạn của hàm số mathvn năm 2024
1 tháng trước . bởi UnfocusedBallet
Giải bài tập công nghệ 7 trong vbt bài 31 năm 2024
1 tháng trước . bởi FundamentalAirtime
Bóng đèn cực tím 1m2 công suất bao nhiêu watt năm 2024
1 tháng trước . bởi TrackingTrilogy
Cơ sở của giá trị hàng hóa là gì năm 2024
1 tháng trước . bởi Fast-foodLineage
Cách sửa lỗi trong speakers properties ko hiện enhancement năm 2024
1 tháng trước . bởi MilitaryTracing
Giải bài tập toán lớp 5 tập 2 bài 163 năm 2024
1 tháng trước . bởi ThoughtlessEnclosure
Miracle in cell number 7 review năm 2024
1 tháng trước . bởi UndeniableFiring
Mục tiêu bài học chi tiết đánh giá được năm 2024
2 tháng trước . bởi ThunderousFlask
Asias next top model 5 tap 6 năm 2024
2 tháng trước . bởi HorribleBattling
Cầu gỗ lim huế bao nhiêu tiền năm 2024
2 tháng trước . bởi YieldingSwimmer

Toplist được quan tâm

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
5 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
5 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
5 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
5 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
5 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
5 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
5 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
5 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
5 tháng trước

Quảng cáo

Xem Nhiều

Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024
1 tuần trước
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
1 tuần trước
Bài tập tìm hằng số cân bằng hoá 11 năm 2024
6 ngày trước
Họ tiếng nhật của bạn là gì năm 2024
1 tuần trước
Băn khoăn có nghĩa là gì năm 2024
1 tuần trước
Goh là viết tắt của gì trong tiếng anh năm 2024
18 giờ trước
Tìm hiểu chung về văn bản nghị luận năm 2024
4 ngày trước
Anh bộ đội cụ hồ gốc bỉ là gì năm 2024
3 ngày trước
Bao cáo đầu tư mua đất để làm văn phòng năm 2024
1 ngày trước
Sử lý lỗi không lăng được chuột trong sketchup năm 2024
4 ngày trước

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

DMCA.com Protection Status
Bản quyền © 2021 Học Tốt Inc.