Hướng dẫn built-in function in python - chức năng tích hợp trong python

Khi thực hiện lập trình, có nhiều thao tác tính toán, các function thực hiện lặp đi lặp lại một công việc, các lập trình viên "già" thường sẽ viết thành các common-libs sau đó chia sẻ lại cho các "đàn em" trong team. Với các tiền bối có "tâm" thì các common-libs sẽ được tối ưu về hiệu năng tính toán hoặc giảm độ phức tạp thuật toán để thời gian xử lý nhanh, chính xác. Với những người còn lại thì ... hên xui :D

Trong ngôn ngữ lập trình Python, có một số "common-libs" được xây dựng hẳn thành build-in functions được tích hợp kèm với trình thông dịch Python, luôn sẵn sàng để "được" sử dụng ngay sau khi khởi tạo môi trường làm việc. Các lập trình viên Python hoàn toàn có thể yên tâm sử dụng các build-in functons này.

Build-in functions là gì?

Build-in functions là những hàm được cung cấp sẵn bởi ngôn ngữ Python, được hiểu là các function được đánh giá là "sử dụng nhiều" khi lập trình. Một số functions kinh điển như: sum, bin, max,

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

0,

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

1, ...Khi sử dụng build-in function, chúng ta sẽ rút ngắn được code và trong một số trường hợp sẽ đảm bảo hiệu năng tính toán [với bài toán số "cực lớn" có thể gây tràn memory thì code tay sẽ cho độ phức tạp tính toán tốt hơn]
Một số functions kinh điển như: sum, bin, max,

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

0,

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

1, ...
Khi sử dụng build-in function, chúng ta sẽ rút ngắn được code và trong một số trường hợp sẽ đảm bảo hiệu năng tính toán [với bài toán số "cực lớn" có thể gây tràn memory thì code tay sẽ cho độ phức tạp tính toán tốt hơn]

Chúng ta có thể xem và tham khảo cách sử dụng các build-in functions bằng cách truy cập vào link từ trang chủ của Python: //docs.python.org/3/library/functions.html

Phần nội dụng dưới đây, tôi sẽ đưa ra một số ví dụ về các build-in function và việc đo đạc hiệu năng của các build-in function và cách làm thông thường.

Việc đo đạc sẽ sử dụng function sau:

import timeit

def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]

1. Sum 

Tính tổng của một danh sách các số truyền vào, kiểu dữ liệu vào là một iterable [list, set,...]: //docs.python.org/3/library/functions.html#sum

Ví dụ về cách sử dụng:

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

2

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

3

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

3

Đo hiệu năng:

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

Kết quả lần 1:

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

4

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

5

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

4

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

5

Kết quả lần 2:

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

6

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

7

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

6

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

7

Kết quả lần 3:

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

8

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

9

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

8

my_list = [10, 20, 30, 40, 50]

# normal function 
sum_basic = 0
for number in my_list:
    sum_basic += number


# build-in function 
sum_build_in = sum[my_list]


print["Normal function:", sum_basic]
print["Buil-in function:", sum_build_in]

9

So sánh

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

0 với

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

1 thì ta thấy dùng build-in function đang nhanh hơn khoảng 45% so với cách làm thông thường.

2. Len

Trả về độ dài của tham số truyền vào, các tham số truyền vào có thể là số, chuỗi, list, dict,... [//docs.python.org/3/library/functions.html#len]

my_string = "The Python interpreter has a number of functions and types built into it that are always available"

# normal function 
length_basic = 0
for _ in my_string:
    length_basic += 1


# build-in function 
length_build_in = len[my_string]


print["Normal function:", length_basic]
print["Buil-in function:", length_build_in]

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

2

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

3

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

3

Đây có lẽ là function được các developer dùng nhiều nhất vì tính tiện lợi và tốc độ trả về của nó. Tại sao thì chúng ta hãy cùng nhau đo benchmark nhé.

import random
import timeit


def length_normal_function[my_data]:
    length_basic = 0
    for _ in my_data:
        length_basic += 1
    return length_basic

def length_build_in_function[my_data]:
    return len[my_data]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    max_length = 5000000 # 5triệu
    my_list = [random.randint[0, 100] for _ in range[max_length]]
    benchmark[length_normal_function, my_list, "length_normal_function"]
    benchmark[length_build_in_function, my_list, "length_build_in_function"]


do_benchmark[]

Lần chạy thứ nhất:

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

4

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

5

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

4

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

5

Lần chạy thứ hai:

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

6

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

7

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

6

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

7

Lần chạy thứ ba:

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

8

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

9

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

8

import random
import timeit

MAX_RANGE = 5000000 # 5 triệu nhé


def sum_normal_function[my_list]:
    sum_basic = 0
    for number in my_list:
        sum_basic += number
    return sum_basic


def sum_build_in_function[my_list]:
    return sum[my_list]


def benchmark[function, params, function_name]:
    start = timeit.default_timer[]
    function[params]
    end = timeit.default_timer[]
    print["{0} seconds for {1}".format[[end - start], function_name]]


def do_benchmark[]:
    my_list = [random.randint[0, MAX_RANGE] for _ in range[MAX_RANGE]]
    benchmark[sum_normal_function, my_list, "sum_normal_function"]
    benchmark[sum_build_in_function, my_list, "sum_build_in_function"]


do_benchmark[]

9

Với kết quả

my_string = "The Python interpreter has a number of functions and types built into it that are always available"

# normal function 
length_basic = 0
for _ in my_string:
    length_basic += 1


# build-in function 
length_build_in = len[my_string]


print["Normal function:", length_basic]
print["Buil-in function:", length_build_in]

0 cho việc sử dụng build-in function thì chả có lý do gì mà chúng ta lại không dùng function sẵn có này nhỉ.

3. Eval

Đây là một build-in function độc đáo mà Python cung cấp cho các lập trình viên. Đầu vào của function này là một chuỗi sau đó sẽ thực hiện tìm kiếm các toán tử và toán hạng sau đó thực hiện tính toán và trả về kết quả. [//docs.python.org/3/library/functions.html#eval]

expression = "number + number + 100 - 35 + 5 * 80"
print["{}: type of {}".format[expression, type[expression]]]


number = 10 
eval_result = eval[expression]
print["{} = {}: type of {}".format[expression, eval_result, type[eval_result]]]

number + number + 100 - 35 + 5 * 80: type of 
number + number + 100 - 35 + 5 * 80 = 485: type of 

Bình thường với các ngôn ngữ lập trình khác, để thực hiện việc chuyển biểu thức thành kết quả tính toán ... là cả một vấn đề khó khăn nhưng với build-in function eval của Python mọi thứ đã đơn giản hơn.

Kết luận

Ngoài các function phía trên, còn kha khá các function khác và vô số lợi ích không tưởng mà chúng mang lại cho các lập trình viên Python. Tuy nhiên, khi làm việc với build-in function, các bạn cần chú ý một chút chút về việc đặt tên các function, name như tôi đã đưa ra ở bài viết: Đặt trùng tên biến và function với keyword.Cảm ơn các bạn đã đọc bài viết của tôi.
Cảm ơn các bạn đã đọc bài viết của tôi.