Bạn có thể tìm số nhỏ nhất của một danh sách trong Python bằng cách sử dụng hàm min[], hàm sort[] hoặc vòng lặp for
Chúng ta sẽ xem xét các quy trình sau để tìm số nhỏ nhất trong danh sách, với các ví dụ
- Sử dụng hàm dựng sẵn min[]
- Sử dụng chức năng List sort[]
- Sử dụng Python cho vòng lặp
Chọn một, dựa trên yêu cầu chương trình của bạn hoặc đề xuất hiệu suất cá nhân của riêng bạn
ví dụ 1. Tìm số nhỏ nhất bằng min[]
hàm min[] có thể lấy một danh sách làm đối số và trả về phần tử tối thiểu trong danh sách
Trong ví dụ này, chúng ta sẽ lấy một danh sách các số và tìm số nhỏ nhất trong danh sách bằng cách sử dụng hàm min[]
Chương trình Python
# python program to find the smallest number
# list of numbers
a = [18, 52, 23, 41, 32]
# find smallest number using min[] function
smallest = min[a]
# print the smallest number
print[f'Smallest number in the list is : {smallest}.']
Chạyđầu ra
Smallest number in the list is : 18.
ví dụ 2. Tìm số nhỏ nhất bằng hàm sort[]
Chúng ta biết rằng hàm sort[] sắp xếp một danh sách theo thứ tự tăng dần hoặc giảm dần. Sau khi bạn sắp xếp danh sách, bạn có số nhỏ nhất ở đầu danh sách nếu bạn đã sắp xếp theo thứ tự tăng dần hoặc ở cuối danh sách nếu bạn đã sắp xếp theo thứ tự giảm dần
Chương trình Python
# python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
Chạyđầu ra
Smallest number is: 18
ví dụ 3. Tìm số nhỏ nhất bằng vòng lặp for
Mặc dù việc tìm số nhỏ nhất bằng cách sử dụng hàm sort[] rất dễ dàng, nhưng việc sử dụng Python For Loop sẽ tương đối nhanh hơn với số lượng thao tác ít hơn. Và ngoài ra, chúng tôi không thay đổi thứ tự của các phần tử trong danh sách đã cho
Chương trình Python
a=[18, 52, 23, 41, 32]
# smallest number
smallest = a[0] if a else None
# find smallest
for i in a:
if i 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 loạt 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 đâyTrong hướng dẫn này, bạn sẽ học cách
- Sử dụng
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 của Python để tìm các giá trị nhỏ nhất và lớn nhất trong dữ liệu của bạnmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Gọi
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với một lần lặp duy nhất hoặc với bất kỳ số lượng đối số thông thường nàomin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Sử dụng
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và từ điểnmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Tinh chỉnh hành vi của
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với các đối sốmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
63 vàSmallest number in the list is : 18.
64Smallest number in the list is : 18.
- Sử dụng biểu thức hiểu và trình tạo làm đối số cho
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Khi bạn đã có kiến thức này, thì bạn sẽ sẵn sàng viết một loạt các ví dụ thực tế sẽ cho thấy tính hữu ích của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Cuối cùng, bạn sẽ 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 trongTiề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 đó về lập trình Python, bao gồm các chủ đề như vòng lặp
# python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
41, 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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Python bao gồm một số chức năng tích hợp 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 chức năng 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 bằng một đối số có thể lặp lại duy nhất hoặc bằng hai hoặc nhiều đối số thông thường. Đó là những gì bạn sẽ làm ngay lập tứcLoại bỏ các quảng cáoGọ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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 tích hợp sẵn 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àySmallest number is: 18
7Cả hai hàm đều lấy một đối số bắt buộc có tên là
Smallest number is: 18
84 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. Smallest number in the list is : 18.
64 và Smallest number in the list is : 18.
63Ghi chú. Trong các chữ ký ở trên, dấu hoa thị [
Smallest number is: 18
87] có nghĩa là các đối số sau đây là các đối số chỉ có từ khóa, trong khi dấu ngoặc vuông [Smallest number is: 18
88] biểu thị rằng nội dung kèm theo là tùy chọnDướ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_______384Lấ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ó
Smallest number in the list is : 18.
64Giữ giá trị để trả về nếu đầu vào có thể lặp lại trốngKhôngSmallest number in the list is : 18.
63Chấ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ố
Smallest number in the list is : 18.
64 và Smallest number in the list is : 18.
63 tùy chọn. Hiện tại, chỉ cần tập trung vào đối số Smallest number is: 18
84, đâ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>>>
Smallest element is: 18
3Trong các ví dụ này, bạn gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
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 ________ 63 trả về số nhỏ nhất trong danh sách đầu vào, ________ 572. Ngược lại, cuộc gọi đầu tiên đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về số lớn nhất trong danh sách hoặc Smallest element is: 18
74. 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 Smallest element is: 18
77 vì không có gì để làm trên một iterable trốngMộ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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
5Những ví dụ này kết hợp các số
Smallest element is: 18
300 và Smallest element is: 18
301 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 đượcTuy nhiên, điều gì sẽ xảy ra nếu bạn trộn lẫn chuỗi và số?
>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
0Bạ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 Smallest element is: 18
306Gọi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với nhiều đối số
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Chữ ký thứ hai của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 cho phép bạn gọi 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ư saumin[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_______5311Chấ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]
Smallest number in the list is : 18.
63Nhận hàm một đối số để tùy chỉnh tiêu chí so sánhKhôngBiế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ố Smallest number in the list is : 18.
64. 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ị Smallest number in the list is : 18.
64 không bắt buộc, 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
>>>
Smallest number in the list is : 18.
6Bạ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ánhLoại bỏ các quảng cáoSử 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 String và Iterables của String
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Theo mặc định,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có thể xử lý các giá trị có thể so sánh được. Mặt khác, bạn nhận được một Smallest element is: 18
306, 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ườngSử 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ùngVí 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>>>
# python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
4Như đã 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ề Smallest element is: 18
329 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về Smallest element is: 18
331. 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ề Smallest element is: 18
333 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 trả về Smallest element is: 18
335. 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 ký tự riêng lẻ có thể lặp lạiSử 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ấtVớ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ự>>>
Smallest number is: 18
8Đằ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 Smallest element is: 18
344 có giá trị số nhỏ hơn chữ thường Smallest element is: 18
345>>>
Smallest number in the list is : 18.
17Hà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
Smallest element is: 18
347 thấp hơn điểm mã cho chữ thường Smallest element is: 18
348Bằ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>>>
Smallest element is: 18
7Điều gì làm cho
Smallest element is: 18
347 nhỏ hơn Smallest element is: 18
348? . 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
4Cuố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>>>
Smallest element is: 18
30Để 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 đầuTrong ví dụ đầu tiên, chữ hoa
Smallest element is: 18
359 xuất hiện trước Smallest element is: 18
360, Smallest element is: 18
348 và Smallest element is: 18
362 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 Smallest element is: 18
364 là chuỗi nhỏ nhất. Trong ví dụ thứ hai, chữ thường Smallest element is: 18
362 xuất hiện sau tất cả các chữ cái đầu tiên của các chuỗi khácLưu ý rằng có hai từ bắt đầu bằng
Smallest element is: 18
362, Smallest element is: 18
367 và Smallest element is: 18
368. 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ề Smallest element is: 18
368 vì Smallest element is: 18
371 xuất hiện sau Smallest element is: 18
372Loại bỏ các quảng cáoXử lý từ điển với min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Khi nói đến việc xử lý từ điển Python với
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4, bạn cần cân nhắc rằng nếu bạn sử dụng trực tiếp từ điển thì cả hai chức năng sẽ hoạt động trên các phím>>>
Smallest element is: 18
31Trong 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 Smallest element is: 18
378 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>>>
Smallest element is: 18
32Sự 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ề
Smallest element is: 18
378, 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>>>
Smallest element is: 18
33Trong 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 Smallest element is: 18
378 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 Smallest element is: 18
378 và trả về giá tối đaCuố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
>>>
Smallest element is: 18
34Trong 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àoPython so sánh các bộ dữ liệu theo từng mục. Ví dụ: để xác định xem
Smallest element is: 18
390 có lớn hơn Smallest element is: 18
391 hay không], Python kiểm tra Smallest element is: 18
392. Nếu điều kiện này là Smallest element is: 18
393, 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 Smallest element is: 18
394, thì Python kết luận rằng bộ thứ nhất nhỏ hơn bộ thứ haiCuối cùng, nếu
Smallest element is: 18
395, thì Python sẽ so sánh cặp mục thứ hai bằ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ộ đế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ứ haiTinh 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 Smallest number in the list is : 18.
63 và Smallest number in the list is : 18.
64
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Smallest number in the list is : 18.
Smallest number in the list is : 18.
Cho đến thời điểm này, bạn đã biết 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 Smallest number in the list is : 18.
63 và Smallest number in the list is : 18.
64Đối số
Smallest number in the list is : 18.
63 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 đaVí 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>>>
Smallest element is: 18
35Đâ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ố
Smallest number in the list is : 18.
63 sang 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>>>
Smallest element is: 18
36Tuyệt quá. Bây giờ kết quả của
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
509. Bạn chỉ cần vượt qua Smallest element is: 18
300 mà không cần cặp dấu ngoặc đơn vì Smallest number in the list is : 18.
63 mong đợi một đối tượng chức năng hoặc chính xác hơn là một đối tượng có thể gọi đượcGhi 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ỉ 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à Smallest number in the list is : 18.
64. 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
Smallest number in the list is : 18.
64 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>>>
Smallest element is: 18
37Trong 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 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 để đưa ra một Smallest element is: 18
77 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 Smallest number in the list is : 18.
64, 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ạnLoại bỏ các quảng cáoSử 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 biểu thức hiểu và trình tạo
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Bạn cũng có thể gọi
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với 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 đaKhi 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 chứ không phải từ dữ liệu gốc>>>
Smallest element is: 18
38Cuộc gọi thứ hai tới
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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
536 bằng cách áp dụng phương pháp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
537 cho từng chữ cái. Kết quả cuối cùng là chữ thường Smallest element is: 18
348, 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
4Lư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ố Smallest number in the list is : 18.
63. 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 Smallest number in the list is : 18.
63, kết quả đến từ dữ liệu gốc>>>
Smallest element is: 18
39Trong 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
537 để bằng cách nào đó sửa đổi các tiêu chí so sánh. 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 được chuyển đổi chứ không phải từ dữ liệu gốcKhả 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ơnCú 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
50Sự 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 [
Smallest number is: 18
88]. 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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Cho đến 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 giá trị có thể lặp lại 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ạoBây giờ bạn đã sẵn sàng để bắt đầu viết mã một số 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ạnLoại bỏ 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
557 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
51Trong các ví dụ này, các giá trị tối thiểu và tối đa trong
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
560 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 đối số cho min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
557Xâ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 các danh sách đại diện cho một ma trận các giá trị số và bạn cần xây dựng 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
52Cách hiểu đầu tiên lặp lại các danh sách con trong
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
566 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 một nhiệm vụ tương tự nhưng sử dụng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
566Mặ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ệcLoại bỏ các quảng cáoCắ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Đợ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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
53Cuộ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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
576 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
577 được cắt thành min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
578, là giới hạn trên của khoảng thời gianNgượ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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
54Cuộc gọi này tới
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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
582 là số duy nhất được cắt bớtCuố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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
55Để cắt tất cả các giá trị nằm ngoài giới hạn của khoảng thời gian, sự hiểu biết này kết hợp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
589 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ảngTì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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
56Trong ví dụ này, trước tiên bạn nhập
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
590 để 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ềuHà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ố Smallest number in the list is : 18.
63 của nó. Trong ví dụ này, Smallest number in the list is : 18.
63 nhận hàm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
595 tính khoảng cách giữa hai điểm. Hàm này trở thành tiêu chí so sánh cho min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 để tìm cặp điểm có khoảng cách giữa các điểm là nhỏ nhấtTrong ví dụ này, bạn cần hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
595 vì Smallest number in the list is : 18.
63 yêu cầu hàm một đối số, trong khi min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
599 yêu cầu hai đối số. Vì vậy, hàm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
595 nhận một đối số duy nhất, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
001, sau đó giải nén nó thành hai đối số để nạp vào min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
599Xác định các 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
Smallest element is: 18
387 và một hàm min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
595 thích hợp làm đối số Smallest number in the list is : 18.
63>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
57Trong ví dụ này, hàm
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
595 lấy một cặp khóa-giá trị làm đối số và trả về giá trị tương ứng để min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 có tiêu chí so sánh 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àoLoại bỏ các quảng cáoTì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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
010 hay khôngTrong 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
58Trong đoạn mã này, bạn định nghĩa
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
011 là một hàm vị ngữ trả về Smallest element is: 18
393 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
013Thành phần chính của hàm là một vòng lặp
# python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
41 lặp lại trên một min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
015 giá trị. Để đặt giới hạn trên cho đối tượng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
015 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
021 đến min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
022>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
59Lệ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
020 chạy một câu lệnh dựa trên chuỗi trong 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ạiBằ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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
026 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 khả năng hiểu danh sách có thể nhanh hơn một chút so với chức năng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
027 tích hợp khi xây dựng danh sách mớiKhám phá vai trò của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029 trong min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Như bạn đã học 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 sẵn đủ 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 nắm bắt 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029 tương ứng hỗ trợ các toán tử nhỏ hơn [min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
040] và lớn hơn [min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
041]. Ý nghĩa của hỗ trợ ở đây là gì? Điều đáng nói 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 triển khai min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029. Đó 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
00Các kiểu dữ liệu tích hợp sẵn của Python triển khai các phương thức đặc biệt
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029. 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 đượcBạn cũng có thể làm cho các phiên bản của các lớp tùy chỉnh của mình tương thích với
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4. Để đạt được điều này, bạn cần cung cấp các triển khai của riêng mình về min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029. Hãy xem xét lớp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
056 sau đây làm ví dụ về khả năng tương thích nàymin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
01Lưu ý rằng việc triển khai
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029 yêu cầu một đối số thường có tên là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
059. Đố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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
042, bạn sẽ có rằng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
061 sẽ là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
062 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
063 sẽ là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
059Ghi 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 hoặc min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029Trong ví dụ này,
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029 trả về kết quả so sánh thuộc tính min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
069 của hai người. Đây là cách nó hoạt động trong thực tế>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
02Mát mẻ. Bạn có thể xử lý các đối tượng
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
056 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029. 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 trẻ 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ấtGhi chú. Các phương pháp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029 chỉ hỗ trợ cho hai toán tử so sánh, min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
040 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
041. 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
082 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 phần còn lại của các phương thức so sánhLư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 phiên bản của nó sẽ không hỗ trợ cá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>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
03Bởi vì lớp
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
085 này không cung cấp triển khai phù hợp của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
028 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
029, 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 phản hồi bằng một Smallest element is: 18
306. 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ạnLoại bỏ các quảng cáoGiả 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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Cho đến thời điểm này, bạn đã học được cách thức 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
4Mặ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 phép tính 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ạnTrong 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ìnhHiể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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Để tìm giá trị 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
04Trong đ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 Smallest number is: 18
84 không trống và các giá trị của nó theo thứ tự tùy ýHàm xử lý giá trị đầu tiên dưới dạng 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 # python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
41 lặp qua các phần tử còn lại trong dữ liệu đầu vàoCâu lệnh điều kiện so sánh ________ 607 hiện tại với ________ 605 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 ứngMỗ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ập nhật. Khi hàm chạy đến cuối Smallest number is: 18
84, 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àoMát mẻ. 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 [________ 7040] thành lớn hơn [________ 7041], và có thể đổi tên hàm và một số để tránh nhầm lẫnChức năng mới của bạn có thể trông giống như thế này
>>>
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
05Lư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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
041] thay vì toán tử nhỏ hơn [min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
040]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 hành vi hoàn chỉnh của min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
3 và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 bằng kỹ năng Python của mình, bạn sẽ giải quyết vấn đề này chỉ trong giây látTrướ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
# python program to find the smallest number
# list
a = [18, 52, 23, 41, 32]
# sort the list, default is in ascending order
a.sort[]
# smallest number
smallest = a[0]
# print the smallest number
print["Smallest number is: ",smallest]
41 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àmNế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áoLậ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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Để 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àoHàm trợ giúp của bạn sẽ có chữ ký sau
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
06Đây là những gì mỗi đối số làm
Đối sốMô tảBắt buộc_______629Cho phép bạn gọi hàm với một số lượng đối số thông thường có thể lặp lại hoặc bất kỳ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óSmallest number in the list is : 18.
63Nhận hàm một đối số sửa đổi tiêu chí và hành vi so sánh của hàmKhôngSmallest number in the list is : 18.
64Lư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àoSau đó, hàm cần xử lý các đối số
Smallest number in the list is : 18.
63 và Smallest number in the list is : 18.
64 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
38Vớ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 đầu trang của 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átChuẩ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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Để 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
07Ở đây, bạn định nghĩa
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 kiểm tra này, bạn sử dụng chức năng min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
49 tích hợpNế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à đố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áchNếu
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
51 tạo ra một Smallest element is: 18
306, thì bạn bắt nó và tạo ra một Smallest element is: 18
306 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 ________ 657 để ẩn truy nguyên của bản gốc ________ 5306Nhá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ạiNếu điều kiện này cuối cùng không tăng
Smallest element is: 18
306, 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ố Smallest number in the list is : 18.
64
Smallest number in the list is : 18.
Để 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ố Smallest number in the list is : 18.
64. Hãy tiếp tục và thêm đoạn mã sau vào cuối hàmmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
08Trong đ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ố Smallest number in the list is : 18.
64 để xem người dùng có cung cấp giá trị cho đối số đó không. Nếu Smallest number in the list is : 18.
64 vẫn là min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
69, thì một Smallest element is: 18
77 được nâng lên. Mặt khác, Smallest number in the list is : 18.
64 đượ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ốngLoại bỏ các quảng cáoXử lý chức năng Smallest number in the list is : 18.
63 tùy chọn
Smallest number in the list is : 18.
Bây giờ, bạn cần xử lý đối số
Smallest number in the list is : 18.
63 và chuẩn bị dữ liệu để tìm các giá trị nhỏ nhất và lớn nhất theo Smallest number in the list is : 18.
63 đượ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ã saumin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
09Bạ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 có cung cấp hàm
Smallest number in the list is : 18.
63 hay không. 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ừ min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
62 ban đầu 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 đaMặt khác, nếu người dùng đã cung cấp đối số
Smallest number in the list is : 18.
63, 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 sẵn, trả về Smallest element is: 18
393 nếu đối số của nó là có thể gọi được và min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
013 nếu không thìKhi bạn chắc chắn rằng
Smallest number in the list is : 18.
63 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 Smallest number in the list is : 18.
63 cho từng giá trị trong dữ liệu đầu vàoCuối cùng, nếu
Smallest number in the list is : 18.
63 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 Smallest element is: 18
306, 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 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 chức năng
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ị tối thiểu và tối đa 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ã saumin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
0Bạn đặt các biến
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
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 đaSau đó, 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 được gọi là ________ 635 để so sánh
Smallest number in the list is : 18.
63 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 ________ 695. 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ữ Smallest number in the list is : 18.
606 hoặc Smallest number in the list is : 18.
607 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ị tối thiểu hoặc tối đa tương ứngVí dụ khi bạn muốn tìm giá trị nhỏ nhất trong dữ liệu nhập vào thì ____
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 _____Smallest number in the list is : 18.
606. 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ữ Smallest number in the list is : 18.
607Mỗi lần lặp lại vòng lặp so sánh
Smallest number in the list is : 18.
63 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
96Mã 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
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Với chức năng trợ giúp của
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 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ạnmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
1Trong đoạn mã này, trước tiên bạn nhập 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[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
041] và nhỏ hơn [min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
040], tương ứng. Ví dụ: biểu thức Boolean min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
042 tương đương với lệnh gọi hàm Smallest number in the list is : 18.
629. 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ìnhCũ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, Smallest number in the list is : 18.
634 và Smallest number in the list is : 18.
635 lấy min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
29, Smallest number in the list is : 18.
63 và Smallest number in the list is : 18.
64 làm đối số và trả về giá trị tối thiểu và tối đa tương ứng. Để thực hiện tính toán, 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 phù hợp min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value
max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
35Trong
Smallest number in the list is : 18.
634, bạn sử dụng Smallest number in the list is : 18.
606 để tìm giá trị nhỏ nhất trong dữ liệu đầu vào. Trong Smallest number in the list is : 18.
635, bạn sử dụng Smallest number in the list is : 18.
607 để có giá trị lớn nhấtNhấ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ìnhMã 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
2Mát mẻ. 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úngLoại bỏ các quảng cáoPhầ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 đã tìm hiểu 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 lập trình hàng ngày của bạnTrong 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
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ương ứngmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Gọi
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với một lần lặp duy nhất và với một số đối số thông thườngmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Sử dụng
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 với chuỗi và từ điểnmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
- Tùy chỉnh hành vi của
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4 vớimin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
63 vàSmallest number in the list is : 18.
64Smallest number in the list is : 18.
- Khả năng hiểu nguồn cấp dữ liệu và biểu thức trình tạo thành
3 vàmin[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
4min[arg_1, arg_2[, ..., arg_n], *[, key]] -> minimum_value max[arg_1, arg_2[, ..., arg_n], *[, key]] -> maximum_value
Ngoài ra, bạn đã mã hóa một số 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 nàyTiề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
Gửi cho tôi thủ thuật Python »
Giới thiệu về Leodanis Pozo Ramos
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ề LeodanisMỗ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à
Aldren
Geir Arne
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 »
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 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ẻ EmailBà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