Được gõ python nhanh hơn

Trăn tinh

Chúng tôi có một cái mà chúng tôi muốn áp dụng một chức năng theo hàng

In [1]: df = pd.DataFrame(
   ...:     {
   ...:         "a": np.random.randn(1000),
   ...:         "b": np.random.randn(1000),
   ...:         "N": np.random.randint(100, 1000, (1000)),
   ...:         "x": "x",
   ...:     }
   ...: )
   ...: 

In [2]: df
Out[2]: 
            a         b    N  x
0    0.469112 -0.218470  585  x
1   -0.282863 -0.061645  841  x
2   -1.509059 -0.723780  251  x
3   -1.135632  0.551225  972  x
4    1.212112 -0.497767  181  x
.        ..       ..  .. ..
995 -1.512743  0.874737  374  x
996  0.933753  1.120790  246  x
997 -0.308013  0.198768  157  x
998 -0.079915  1.757555  977  x
999 -1.010589 -1.115680  770  x

[1000 rows x 4 columns]

Đây là chức năng trong Python thuần túy

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Chúng tôi đạt được kết quả của mình bằng cách sử dụng (hàng khôn ngoan)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Nhưng rõ ràng điều này không đủ nhanh đối với chúng tôi. Hãy xem và xem thời gian được sử dụng ở đâu trong quá trình thao tác này (giới hạn ở bốn cuộc gọi tốn nhiều thời gian nhất) bằng cách sử dụng

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Cho đến nay, phần lớn thời gian được sử dụng bên trong

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

Đồng bằng Cython

Trước tiên, chúng ta sẽ cần nhập hàm ma thuật Cython vào IPython

In [7]: %load_ext Cython

Bây giờ, chúng ta chỉ cần sao chép các chức năng của chúng ta sang Cython (hậu tố ở đây để phân biệt giữa các phiên bản chức năng)

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

Ghi chú

Nếu bạn gặp sự cố khi dán phần trên vào ipython của mình, bạn có thể cần phải sử dụng IPython cạnh chảy máu để dán để chơi tốt với ma thuật di động

________số 8_______

Điều này đã loại bỏ một phần ba, không quá tệ đối với một bản sao và dán đơn giản

Thêm loại

Chúng tôi nhận được một cải tiến lớn khác chỉ đơn giản bằng cách cung cấp thông tin loại

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [11]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
9.47 ms +- 279 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

Bây giờ chúng ta nói chuyện. Nó hiện nhanh hơn mười lần so với triển khai Python ban đầu và chúng tôi chưa thực sự sửa đổi mã. Chúng ta hãy có một cái nhìn khác về những gì đang ăn hết thời gian

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

sử dụng ndarray

Nó gọi hàng loạt rất nhiều. Nó đang tạo một từ mỗi hàng và gọi get từ cả chỉ mục và chuỗi (ba lần cho mỗi hàng). Các cuộc gọi hàm rất tốn kém trong Python, vì vậy có lẽ chúng ta có thể giảm thiểu chúng bằng cách cythonizing phần áp dụng

Ghi chú

Chúng tôi hiện đang chuyển ndarrays vào hàm Cython, may mắn thay Cython chơi rất tốt với NumPy

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Việc triển khai rất đơn giản, nó tạo ra một mảng các số không và lặp qua các hàng, áp dụng

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

Cảnh báo

Bạn không thể chuyển trực tiếp dưới dạng tham số đã nhập

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

Vì vậy, không làm điều này

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Nhưng thay vào đó, sử dụng để lấy

In [8]: %%cython
   ...: def f_plain(x):
   ...:     return x * (x - 1)
   ...: def integrate_f_plain(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f_plain(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Ghi chú

Các vòng lặp như thế này sẽ cực kỳ chậm trong Python, nhưng trong Cython, việc lặp qua các mảng NumPy rất nhanh

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Chúng tôi đã nhận được một cải tiến lớn khác. Hãy kiểm tra lại xem thời gian đã được sử dụng ở đâu

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Như mọi người có thể mong đợi, phần lớn thời gian hiện được dành cho

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

Các kỹ thuật nâng cao hơn

Vẫn còn hy vọng cải thiện. Đây là một ví dụ về việc sử dụng một số kỹ thuật Cython nâng cao hơn

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Thậm chí còn nhanh hơn, với lời cảnh báo rằng một lỗi trong mã Cython của chúng tôi (ví dụ: lỗi từng lỗi một) có thể gây ra lỗi phân tách vì quyền truy cập bộ nhớ không được kiểm tra. Để biết thêm về

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

gấu trúc Numba Engine

Nếu Numba được cài đặt, người ta có thể chỉ định

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [11]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
9.47 ms +- 279 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

Về mặt hiệu suất, lần đầu tiên một chức năng được chạy bằng công cụ Numba sẽ chậm vì Numba sẽ có một số chi phí biên dịch chức năng. Tuy nhiên, các chức năng được biên dịch JIT được lưu vào bộ đệm và các cuộc gọi tiếp theo sẽ nhanh chóng. Nói chung, công cụ Numba hoạt động hiệu quả với số lượng điểm dữ liệu lớn hơn (e. g. hơn 1 triệu)

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Nếu phần cứng máy tính của bạn chứa nhiều CPU, bạn có thể đạt được mức tăng hiệu suất lớn nhất bằng cách đặt

In [11]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
9.47 ms +- 279 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

In [11]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
9.47 ms +- 279 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Ví dụ về chức năng tùy chỉnh

Có thể sử dụng một hàm Python tùy chỉnh được trang trí bằng

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [10]: %%cython
   ....: cdef double f_typed(double x) except? -2:
   ....:     return x * (x - 1)
   ....: cpdef double integrate_f_typed(double a, double b, int N):
   ....:     cdef int i
   ....:     cdef double s, dx
   ....:     s = 0
   ....:     dx = (b - a) / N
   ....:     for i in range(N):
   ....:         s += f_typed(a + i * dx)
   ....:     return s * dx
   ....: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Trong ví dụ này, sử dụng Numba nhanh hơn Cython

Numba cũng có thể được sử dụng để viết các hàm vector hóa không yêu cầu người dùng lặp lại một cách rõ ràng các quan sát của một vector; . Xem xét ví dụ sau về việc nhân đôi mỗi quan sát

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Hãy cẩn thận

Numba là cách tốt nhất để tăng tốc các hàm áp dụng các hàm số cho mảng NumPy. Nếu bạn cố gắng

In [9]: %timeit df.apply(lambda x: integrate_f_plain(x["a"], x["b"], x["N"]), axis=1)
50.9 ms +- 160 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [11]: %timeit df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
9.47 ms +- 279 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

Sử dụng

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

Nói chung, nếu bạn gặp phải một segfault (

In [12]: %prun -l 4 df.apply(lambda x: integrate_f_typed(x["a"], x["b"], x["N"]), axis=1)
         68904 function calls (68884 primitive calls) in 0.026 seconds

   Ordered by: internal time
   List reduced from 224 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)
    16174    0.002    0.000    0.003    0.000 {built-in method builtins.isinstance}
     3000    0.002    0.000    0.003    0.000 base.py:3754(get_loc)

Cú pháp được hỗ trợ

Các hoạt động này được hỗ trợ bởi

• Các phép toán số học ngoại trừ toán tử dịch trái (

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  12) và dịch phải (

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  13), e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  14

• Các hoạt động so sánh, bao gồm so sánh chuỗi, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  15

• Phép toán Boolean, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  16

• In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  17 và

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  18 chữ thường, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  19 hoặc

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  20

• Quyền truy cập thuộc tính, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  21

• biểu thức chỉ số, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  22

• Đánh giá biến đơn giản, e. g. ,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  23 (điều này không hữu ích lắm)

• hàm toán học.

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  24,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  25,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  26,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  27,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  28,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  29,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  30,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  31,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  32,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  33,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  34,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  35,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  36,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  37,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  38,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  39,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  34,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  40,

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  42 và

  In [3]: def f(x):
     ...:     return x * (x - 1)
     ...: 
  
  In [4]: def integrate_f(a, b, N):
     ...:     s = 0
     ...:     dx = (b - a) / N
     ...:     for i in range(N):
     ...:         s += f(a + i * dx)
     ...:     return s * dx
     ...: 
  

  42

Cú pháp Python này không được phép

• Biểu thức

  • Các lệnh gọi hàm khác với các hàm toán học

  • Hoạt động

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    43/

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    44

  • In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    45 biểu thức

  • In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    46 biểu thức

  • In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    17/

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    48/

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    49 comprehensions

  • Các biểu thức

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    49 và

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    48 theo nghĩa đen

  • In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    52 biểu thức

  • biểu thức trình tạo

  • Biểu thức Boolean chỉ bao gồm các giá trị vô hướng

• Các câu lệnh

  • Không cho phép câu lệnh đơn hay phức. Điều này bao gồm những thứ như

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    53,

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    54 và

    In [3]: def f(x):
       ...:     return x * (x - 1)
       ...: 
    
    In [4]: def integrate_f(a, b, N):
       ...:     s = 0
       ...:     dx = (b - a) / N
       ...:     for i in range(N):
       ...:         s += f(a + i * dx)
       ...:     return s * dx
       ...: 
    

    45

ví dụ

hoạt động tốt với các biểu thức chứa mảng lớn

Trước tiên, hãy tạo một vài mảng có kích thước phù hợp để chơi với

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Bây giờ, hãy so sánh việc thêm chúng lại với nhau bằng cách sử dụng Python thuần túy so với

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Bây giờ hãy làm điều tương tự nhưng với sự so sánh

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

cũng hoạt động với các đối tượng gấu trúc chưa được phân bổ

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Ghi chú

Các thao tác như

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

0

nên được thực hiện bằng Python. Một ngoại lệ sẽ được đưa ra nếu bạn cố gắng thực hiện bất kỳ thao tác boolean/bitwise nào với toán hạng vô hướng không thuộc loại

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

phương pháp

Ngoài chức năng cấp cao nhất, bạn cũng có thể đánh giá một biểu thức trong “ngữ cảnh” của một

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Bất kỳ biểu thức nào là biểu thức hợp lệ cũng là biểu thức hợp lệ, với lợi ích bổ sung là bạn không phải thêm tiền tố vào tên của (các) cột mà bạn muốn đánh giá

Ngoài ra, bạn có thể thực hiện gán các cột trong một biểu thức. Điều này cho phép đánh giá công thức. Mục tiêu gán có thể là tên cột mới hoặc tên cột hiện có và nó phải là mã định danh Python hợp lệ

Từ khóa

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Khi

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Để thuận tiện, có thể thực hiện nhiều nhiệm vụ bằng cách sử dụng chuỗi nhiều dòng

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Tương đương trong tiêu chuẩn Python sẽ là

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Phương thức này có từ khóa

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Biến cục bộ

Bạn phải tham chiếu rõ ràng bất kỳ biến cục bộ nào mà bạn muốn sử dụng trong một biểu thức bằng cách đặt ký tự

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Nếu bạn không đặt tiền tố cho biến cục bộ bằng

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Khi sử dụng and , điều này cho phép bạn có một biến cục bộ và một cột có cùng tên trong một biểu thức

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Với bạn hoàn toàn không thể sử dụng tiền tố

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [6]: %prun -l 4 df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)  # noqa E999
         621327 function calls (621307 primitive calls) in 0.168 seconds

   Ordered by: internal time
   List reduced from 225 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.093    0.000    0.143    0.000 <ipython-input-4-c2a74e076cf0>:1(integrate_f)
   552423    0.050    0.000    0.050    0.000 <ipython-input-3-c138bdd570e3>:1(f)
     3000    0.004    0.000    0.018    0.000 series.py:966(__getitem__)
     3000    0.002    0.000    0.009    0.000 series.py:1072(_get_value)

Trong trường hợp này, bạn chỉ nên tham khảo các biến giống như trong Python chuẩn

In [7]: %load_ext Cython

trình phân tích cú pháp

Có hai trình phân tích cú pháp khác nhau và hai công cụ khác nhau mà bạn có thể sử dụng làm phụ trợ

Trình phân tích cú pháp

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Ví dụ, liên từ trên có thể được viết mà không có dấu ngoặc đơn. Ngoài ra, bạn có thể sử dụng trình phân tích cú pháp

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [7]: %load_ext Cython

Biểu thức tương tự cũng có thể được "anded" cùng với từ

In [7]: %load_ext Cython

Các toán tử

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

phụ trợ

Ngoài ra còn có tùy chọn để làm cho hoạt động giống hệt với Python thuần túy

Ghi chú

Sử dụng công cụ

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Bạn có thể thấy điều này bằng cách sử dụng với công cụ

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

In [7]: %load_ext Cython

In [7]: %load_ext Cython

hiệu suất

được dự định để tăng tốc một số loại hoạt động. Đặc biệt, những hoạt động liên quan đến các biểu thức phức tạp với các đối tượng / lớn sẽ thấy lợi ích hiệu suất đáng kể. Đây là một biểu đồ hiển thị thời gian chạy dưới dạng hàm của kích thước của khung liên quan đến tính toán. Hai dòng là hai động cơ khác nhau

Ghi chú

Các thao tác với các đối tượng nhỏ (khoảng 15k-20k hàng) nhanh hơn khi sử dụng Python đơn giản

Biểu đồ này được tạo bằng cách sử dụng a với 3 cột, mỗi cột chứa các giá trị dấu phẩy động được tạo bằng cách sử dụng

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

Chi tiết kỹ thuật liên quan đến đánh giá biểu thức

Các biểu thức dẫn đến một đối tượng dtype hoặc liên quan đến các thao tác ngày giờ (vì

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Kết quả là điều này chỉ áp dụng cho các biểu thức object-dtype. Vì vậy, nếu bạn có một biểu thức-ví dụ

In [7]: %load_ext Cython

phần số của phép so sánh (

In [5]: %timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
86 ms +- 1.44 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: 

Nói chung, / sẽ đánh giá các biểu thức con có thể được đánh giá bởi

In [3]: def f(x):
   ...:     return x * (x - 1)
   ...: 

In [4]: def integrate_f(a, b, N):
   ...:     s = 0
   ...:     dx = (b - a) / N
   ...:     for i in range(N):
   ...:         s += f(a + i * dx)
   ...:     return s * dx
   ...: