Hướng dẫn how do you evenly space an array in python? - làm thế nào để bạn chia đều một mảng trong python?

Question

Khi bạn làm việc với các ứng dụng số bằng Numpy, bạn thường cần tạo một loạt các số. Trong nhiều trường hợp, bạn muốn các con số được đặt cách đều nhau, nhưng cũng có những lúc bạn có thể cần các số không đều nhau. Một trong những công cụ chính bạn có thể sử dụng trong cả hai tình huống là

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9.
1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) ** 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011
9.

Nội dung chính Show

Tạo phạm vi số lượng với khoảng cách thậm chí
Sử dụng 1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) ** 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011 9
Lưu ý rằng giá trị >>> np.arange(2.34, 31.97, 2) array([ 2.34, 4.34, 6.34, 8.34, 10.34, 12.34, 14.34, 16.34, 18.34, 20.34, 22.34, 24.34, 26.34, 28.34, 30.34]) 4 được bao gồm trong mảng đầu ra. Hàm trả về một phạm vi đóng, một phạm vi bao gồm điểm cuối, theo mặc định. Điều này trái với những gì bạn có thể mong đợi từ Python, trong đó kết thúc của một phạm vi thường được bao gồm. Sự phá vỡ này với quy ước không phải là một sự giám sát. Sau này, bạn sẽ thấy rằng đây thường là những gì bạn muốn khi sử dụng chức năng này.
Sử dụng >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 05
Đối số >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 13 cũng có thể là một số điểm nổi, mặc dù bạn sẽ cần phải thận trọng trong trường hợp này vì đầu ra có thể không phải lúc nào cũng hoàn toàn là những gì bạn dự định:
Ở đây, một quy tắc tốt để quyết định sử dụng chức năng nào trong hai chức năng:
Tham số >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 57 để thay đổi loại đầu ra
Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.
Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.
Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.
Kích thước bước là >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 94, nếu >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 68 được đặt thành >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 75
Sự khác biệt so với ví dụ trước trong mã trên là bạn sử dụng mảng >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 16 làm đối số đầu tiên trong >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 19. Điều này đưa ra cốt truyện sau:
Đại diện cho các chức năng toán học
Ví dụ: Sóng du lịch chồng lên
Chức năng toán học hai chiều
Tạo phạm vi số với khoảng cách không đồng đều
Không gian logarit
Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.
Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.
Dòng đầu tiên biến một không gian tuyến tính thành một không gian phi tuyến. Các khoảng giữa mỗi giá trị của >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 22 aren bằng nhau nhưng thay đổi tùy theo hàm cosin. Điều này đưa ra cốt truyện sau:
Hàm Numpy được sử dụng để tạo ra các mảng cách đều nhau là gì?
Bạn có thể thay đổi kích thước mảng trong Python không?
Linspace hoạt động như thế nào?
Bạn có thể chia một mảng trong Python không?

Ở dạng cơ bản của nó,

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 có vẻ tương đối đơn giản để sử dụng. Tuy nhiên, nó là một phần thiết yếu của bộ công cụ lập trình số. Nó có cả hai rất linh hoạt và mạnh mẽ. Trong hướng dẫn này, bạn sẽ tìm ra cách sử dụng chức năng này một cách hiệu quả.

Trong hướng dẫn này, bạn sẽ học cách:

Tạo một phạm vi số đồng đều hoặc không đồng đềurange of numbers

Quyết định khi nào nên sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 thay vì các công cụ thay thế1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) ** 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011
9 instead of alternative tools

Sử dụng các tham số đầu vào cần thiết và tùy chọninput parameters
Tạo các mảng có hai hoặc nhiều chiềutwo or more dimensions
Biểu diễn các chức năng toán học ở dạng riêng biệtmathematical functions in discrete form

Hướng dẫn này giả định rằng bạn đã quen thuộc với những điều cơ bản của Numpy và loại dữ liệu

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2. Bạn sẽ bắt đầu bằng cách tìm hiểu về nhiều cách khác nhau để tạo ra một loạt các con số trong Python. Sau đó, bạn sẽ xem xét kỹ hơn tất cả các cách sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 và cách bạn có thể sử dụng nó một cách hiệu quả trong các chương trình của mình.

Tạo phạm vi số lượng với khoảng cách thậm chí

Có một số cách mà bạn có thể tạo ra một loạt các số cách đều nhau trong Python.

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 cho phép bạn thực hiện việc này và tùy chỉnh phạm vi để phù hợp với nhu cầu cụ thể của bạn, nhưng nó không phải là cách duy nhất để tạo ra một loạt các số. Trong phần tiếp theo, bạn sẽ học cách sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 trước khi so sánh nó với các cách khác để tạo ra các phạm vi cách đều nhau.evenly spaced numbers in Python.

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 allows you to do this and to customize the range to fit your specific needs, but it’s not the only way to create a range of numbers. In the next section, you’ll learn how to use

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 before comparing it with other ways of creating ranges of evenly spaced numbers.

Sử dụng 1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) 2 8... 9>>> def test_list(): 10... return [(number + 2.5) 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011 9

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 có hai tham số bắt buộc,

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 mà bạn có thể sử dụng để đặt đầu và kết thúc phạm vi:>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])
8 and >>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])
9, which you can use to set the beginning and end of the range:

>>>

>>> import numpy as np
>>> np.linspace(1, 10)
array([ 1.        ,  1.18367347,  1.36734694,  1.55102041,  1.73469388,
        1.91836735,  2.10204082,  2.28571429,  2.46938776,  2.65306122,
        2.83673469,  3.02040816,  3.20408163,  3.3877551 ,  3.57142857,
        3.75510204,  3.93877551,  4.12244898,  4.30612245,  4.48979592,
        4.67346939,  4.85714286,  5.04081633,  5.2244898 ,  5.40816327,
        5.59183673,  5.7755102 ,  5.95918367,  6.14285714,  6.32653061,
        6.51020408,  6.69387755,  6.87755102,  7.06122449,  7.24489796,
        7.42857143,  7.6122449 ,  7.79591837,  7.97959184,  8.16326531,
        8.34693878,  8.53061224,  8.71428571,  8.89795918,  9.08163265,
        9.26530612,  9.44897959,  9.63265306,  9.81632653, 10.        ])

Mã này trả về một

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 với các khoảng cách đều nhau giữa các giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Đây là một không gian vector, còn được gọi là không gian tuyến tính, đó là nơi tên

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 đến từ.vector space, also called a linear space, which is where the name

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 comes from.

Lưu ý rằng giá trị

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4 được bao gồm trong mảng đầu ra. Hàm trả về một phạm vi đóng, một phạm vi bao gồm điểm cuối, theo mặc định. Điều này trái với những gì bạn có thể mong đợi từ Python, trong đó kết thúc của một phạm vi thường được bao gồm. Sự phá vỡ này với quy ước không phải là một sự giám sát. Sau này, bạn sẽ thấy rằng đây thường là những gì bạn muốn khi sử dụng chức năng này.closed range, one that includes the endpoint, by default. This is contrary to what you might expect from Python, in which the end of a range usually isn’t included. This break with convention isn’t an oversight. You’ll see later on that this is usually what you want when using this function.

Mảng trong ví dụ trên có độ dài

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

5, là số mặc định. Trong hầu hết các trường hợp, bạn sẽ muốn đặt số lượng giá trị của riêng mình trong mảng. Bạn có thể làm như vậy với tham số tùy chọn

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

6:>>> np.arange(2.34, 31.97, 2) array([ 2.34, 4.34, 6.34, 8.34, 10.34, 12.34, 14.34, 16.34, 18.34, 20.34, 22.34, 24.34, 26.34, 28.34, 30.34])
6:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

Mã này trả về một

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 với các khoảng cách đều nhau giữa các giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Đây là một không gian vector, còn được gọi là không gian tuyến tính, đó là nơi tên

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 đến từ.

>>>

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

Mã này trả về một

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 với các khoảng cách đều nhau giữa các giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Đây là một không gian vector, còn được gọi là không gian tuyến tính, đó là nơi tên

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 đến từ.positional argument, without explicitly mentioning its name in the function call. This is the form you’re likely to use most often.

Lưu ý rằng giá trị >>> np.arange(2.34, 31.97, 2) array([ 2.34, 4.34, 6.34, 8.34, 10.34, 12.34, 14.34, 16.34, 18.34, 20.34, 22.34, 24.34, 26.34, 28.34, 30.34]) 4 được bao gồm trong mảng đầu ra. Hàm trả về một phạm vi đóng, một phạm vi bao gồm điểm cuối, theo mặc định. Điều này trái với những gì bạn có thể mong đợi từ Python, trong đó kết thúc của một phạm vi thường được bao gồm. Sự phá vỡ này với quy ước không phải là một sự giám sát. Sau này, bạn sẽ thấy rằng đây thường là những gì bạn muốn khi sử dụng chức năng này.

Mảng trong ví dụ trên có độ dài

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

5, là số mặc định. Trong hầu hết các trường hợp, bạn sẽ muốn đặt số lượng giá trị của riêng mình trong mảng. Bạn có thể làm như vậy với tham số tùy chọn

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

6:

Mảng đầu ra trong trường hợp này chứa

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4 các giá trị cách đều nhau giữa

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 và

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4, đây chỉ là các số từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4. Ở đây, một ví dụ khác:

>>>

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Mã này trả về một

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 với các khoảng cách đều nhau giữa các giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Đây là một không gian vector, còn được gọi là không gian tuyến tính, đó là nơi tên

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 đến từ.

Lưu ý rằng giá trị

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4 được bao gồm trong mảng đầu ra. Hàm trả về một phạm vi đóng, một phạm vi bao gồm điểm cuối, theo mặc định. Điều này trái với những gì bạn có thể mong đợi từ Python, trong đó kết thúc của một phạm vi thường được bao gồm. Sự phá vỡ này với quy ước không phải là một sự giám sát. Sau này, bạn sẽ thấy rằng đây thường là những gì bạn muốn khi sử dụng chức năng này.

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

Mã này trả về một

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 với các khoảng cách đều nhau giữa các giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Đây là một không gian vector, còn được gọi là không gian tuyến tính, đó là nơi tên

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

3 đến từ.

Lưu ý rằng giá trị

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4 được bao gồm trong mảng đầu ra. Hàm trả về một phạm vi đóng, một phạm vi bao gồm điểm cuối, theo mặc định. Điều này trái với những gì bạn có thể mong đợi từ Python, trong đó kết thúc của một phạm vi thường được bao gồm. Sự phá vỡ này với quy ước không phải là một sự giám sát. Sau này, bạn sẽ thấy rằng đây thường là những gì bạn muốn khi sử dụng chức năng này.

Mảng trong ví dụ trên có độ dài

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

5, là số mặc định. Trong hầu hết các trường hợp, bạn sẽ muốn đặt số lượng giá trị của riêng mình trong mảng. Bạn có thể làm như vậy với tham số tùy chọn

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

6:execution speed. You can expand the section below to see how using a list performs in comparison to using a NumPy array.

Bạn có thể so sánh phương thức bằng cách sử dụng Numpy với phương pháp bằng cách sử dụng toàn bộ danh sách bằng cách tạo các hàm thực hiện cùng một thao tác số học trên tất cả các phần tử trong cả hai chuỗi. Trong ví dụ dưới đây, bạn chia phạm vi từ

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

3 thành

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4 thành các mẫu

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

00, giống như các khoảng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

01:

>>>

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

Các hàm

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

02 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

03 thực hiện các hoạt động tương tự trên các chuỗi. Bạn có thể xác nhận điều này bằng cách kiểm tra xem các đầu ra từ cả hai chức năng là như nhau, như được hiển thị trên dòng 12 trong đoạn mã ở trên. Sử dụng mô -đun

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

04 theo thời gian thực hiện cả hai phiên bản cho thấy rằng việc sử dụng danh sách có thể chậm hơn đáng kể so với sử dụng các mảng numpy.

Sử dụng các công cụ Numpy thay vì Python lõi có thể mang lại hiệu quả tăng trong một số trường hợp. Trong các ứng dụng yêu cầu nhiều tính toán trên một lượng lớn dữ liệu, sự gia tăng hiệu quả này có thể là đáng kể.

Sử dụng >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 05

Numpy có phiên bản riêng của

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6 tích hợp. Nó được gọi là

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05, và không giống như

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6, nó không bị giới hạn ở các số nguyên. Bạn có thể sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 theo cách tương tự như

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6, sử dụng

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8,

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 làm tham số đầu vào:

>>>

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

Các hàm

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

02 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

03 thực hiện các hoạt động tương tự trên các chuỗi. Bạn có thể xác nhận điều này bằng cách kiểm tra xem các đầu ra từ cả hai chức năng là như nhau, như được hiển thị trên dòng 12 trong đoạn mã ở trên. Sử dụng mô -đun

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

04 theo thời gian thực hiện cả hai phiên bản cho thấy rằng việc sử dụng danh sách có thể chậm hơn đáng kể so với sử dụng các mảng numpy.

Sử dụng các công cụ Numpy thay vì Python lõi có thể mang lại hiệu quả tăng trong một số trường hợp. Trong các ứng dụng yêu cầu nhiều tính toán trên một lượng lớn dữ liệu, sự gia tăng hiệu quả này có thể là đáng kể.half-open interval, which excludes the endpoint of the range. This behavior is similar to

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6 but different from

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9. These differences can be a bit confusing initially, but you’ll get used to them as you start using these functions more often.

Sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05

>>>

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

Các hàm

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

02 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

03 thực hiện các hoạt động tương tự trên các chuỗi. Bạn có thể xác nhận điều này bằng cách kiểm tra xem các đầu ra từ cả hai chức năng là như nhau, như được hiển thị trên dòng 12 trong đoạn mã ở trên. Sử dụng mô -đun

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

04 theo thời gian thực hiện cả hai phiên bản cho thấy rằng việc sử dụng danh sách có thể chậm hơn đáng kể so với sử dụng các mảng numpy.

Sử dụng các công cụ Numpy thay vì Python lõi có thể mang lại hiệu quả tăng trong một số trường hợp. Trong các ứng dụng yêu cầu nhiều tính toán trên một lượng lớn dữ liệu, sự gia tăng hiệu quả này có thể là đáng kể.

>>>

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

Sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05

Numpy có phiên bản riêng của

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6 tích hợp. Nó được gọi là

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05, và không giống như

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6, nó không bị giới hạn ở các số nguyên. Bạn có thể sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 theo cách tương tự như

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6, sử dụng

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8,

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 làm tham số đầu vào:

Các giá trị đầu ra là như nhau, mặc dù

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

6 trả về một đối tượng phạm vi, có thể được chuyển đổi thành danh sách để hiển thị tất cả các giá trị, trong khi

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 trả về một mảng.

Mảng được trả về bởi
>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
05 sử dụng khoảng nửa mở, loại trừ điểm cuối của phạm vi. Hành vi này tương tự như
>>> np.arange(1.034, 3.104, 0.34) array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074]) >>> np.arange(1.034, 3.104, 0.345) array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])
6 nhưng khác với
1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) ** 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011
9. Những khác biệt này có thể hơi khó hiểu ban đầu, nhưng bạn sẽ quen với chúng khi bạn bắt đầu sử dụng các chức năng này thường xuyên hơn. when the exact values for the

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 and

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

22 points of your range are the important attributes in your application.

Bạn thậm chí có thể sử dụng các số không định số với
>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
05: when the

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 size between values is more important.

Đầu ra là một mảng bắt đầu từ giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8, với khoảng cách giữa mỗi số chính xác bằng kích thước

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 được sử dụng trong các đối số đầu vào. Số cuối cùng là số lớn nhất trong loạt bài này nhỏ hơn số được sử dụng cho

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

22 của phạm vi.

Đối số >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 13 cũng có thể là một số điểm nổi, mặc dù bạn sẽ cần phải thận trọng trong trường hợp này vì đầu ra có thể không phải lúc nào cũng hoàn toàn là những gì bạn dự định:

Trong ví dụ đầu tiên, mọi thứ có vẻ tốt. Tuy nhiên, bạn có thể nhận thấy rằng trong ví dụ thứ hai, khi

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 là 0,345, giá trị cuối cùng trong đầu ra bằng với giá trị

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 mặc dù

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 sử dụng khoảng nửa mở. Tài liệu cho

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 có cảnh báo về điều này:

Khi sử dụng bước không định cư, chẳng hạn như 0,1, kết quả thường sẽ không nhất quán. Tốt hơn là sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

28 cho những trường hợp này. (Nguồn)

Ở đây, một quy tắc tốt để quyết định sử dụng chức năng nào trong hai chức năng:

Sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 khi các giá trị chính xác cho các điểm

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

22 trong phạm vi của bạn là các thuộc tính quan trọng trong ứng dụng của bạn.

Sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 khi kích thước

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

13 giữa các giá trị quan trọng hơn.sampling, or resolution, of the array you’re creating. Have a look at a few more examples:

>>>

>>> np.linspace(-5, 5, 10)
array([-5.        , -3.88888889, -2.77777778, -1.66666667, -0.55555556,
        0.55555556,  1.66666667,  2.77777778,  3.88888889,  5.        ])

>>> np.linspace(-5, 5, 100)
array([-5.        , -4.8989899 , -4.7979798 , -4.6969697 , -4.5959596 ,
       -4.49494949, -4.39393939, -4.29292929, -4.19191919, -4.09090909,
       -3.98989899, -3.88888889, -3.78787879, -3.68686869, -3.58585859,
       -3.48484848, -3.38383838, -3.28282828, -3.18181818, -3.08080808,
       -2.97979798, -2.87878788, -2.77777778, -2.67676768, -2.57575758,
       -2.47474747, -2.37373737, -2.27272727, -2.17171717, -2.07070707,
       -1.96969697, -1.86868687, -1.76767677, -1.66666667, -1.56565657,
       -1.46464646, -1.36363636, -1.26262626, -1.16161616, -1.06060606,
       -0.95959596, -0.85858586, -0.75757576, -0.65656566, -0.55555556,
       -0.45454545, -0.35353535, -0.25252525, -0.15151515, -0.05050505,
        0.05050505,  0.15151515,  0.25252525,  0.35353535,  0.45454545,
        0.55555556,  0.65656566,  0.75757576,  0.85858586,  0.95959596,
        1.06060606,  1.16161616,  1.26262626,  1.36363636,  1.46464646,
        1.56565657,  1.66666667,  1.76767677,  1.86868687,  1.96969697,
        2.07070707,  2.17171717,  2.27272727,  2.37373737,  2.47474747,
        2.57575758,  2.67676768,  2.77777778,  2.87878788,  2.97979798,
        3.08080808,  3.18181818,  3.28282828,  3.38383838,  3.48484848,
        3.58585859,  3.68686869,  3.78787879,  3.88888889,  3.98989899,
        4.09090909,  4.19191919,  4.29292929,  4.39393939,  4.49494949,
        4.5959596 ,  4.6969697 ,  4.7979798 ,  4.8989899 ,  5.        ])

Bạn sẽ sử dụng

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

05 một lần nữa trong hướng dẫn này. Để tìm hiểu thêm về nó, hãy xem Numpy Arange (): Cách sử dụng np.arange ().

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

0

Tùy chỉnh đầu ra từ

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9

Sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 với các tham số

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8,

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 và

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

6 là cách sử dụng chức năng phổ biến nhất và đối với nhiều ứng dụng, bạn đã giành được cách nhìn vượt ra ngoài phương pháp này. Tuy nhiên, bạn có thể tùy chỉnh đầu ra của bạn hơn nữa.

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

1

Trong phần này, bạn sẽ học cách tùy chỉnh phạm vi mà LỚN đã tạo, xác định các loại dữ liệu của các mục trong mảng và kiểm soát hành vi của điểm cuối.

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

6

Thông thường, bạn sẽ sử dụng chức năng này chỉ với ba tham số đầu vào này. Tuy nhiên, như bạn sẽ thấy trong các phần tiếp theo, bạn có thể sửa đổi đầu ra hơn nữa.

Tham số >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 57 để thay đổi loại đầu ra

Các yếu tố của một mảng numpy đều thuộc về cùng một loại dữ liệu.

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 thường trả về các mảng phao. Bạn có thể thấy điều này cả bằng cách kiểm tra đầu ra hoặc, tốt hơn nữa, bằng cách xem thuộc tính

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

59 cho mảng:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

2

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

3

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

60.

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

4

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

5

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

6

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

60.

Bạn có thể sử dụng tham số đầu vào

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

57 tùy chọn để thay đổi loại dữ liệu của các phần tử trong mảng đầu ra:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

7

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.

Bạn có thể sử dụng tham số đầu vào

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

57 tùy chọn để thay đổi loại dữ liệu của các phần tử trong mảng đầu ra:

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

8

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

60.

>>>

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

9

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.

Bạn có thể sử dụng tham số đầu vào

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

57 tùy chọn để thay đổi loại dữ liệu của các phần tử trong mảng đầu ra:higher-dimensional array:

>>>

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

0

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

60.

>>>

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

1

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

60.

>>>

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

2

Các số trong mảng là phao. Điều này đúng ngay cả trong các trường hợp như sau:

Mặc dù tất cả các yếu tố là toàn bộ số, nhưng chúng vẫn được hiển thị với một khoảng thời gian kéo dài để cho thấy rằng chúng nổi. Bạn xác nhận rằng bằng cách xem xét giá trị của >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 60.

Bạn có thể sử dụng tham số đầu vào

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

57 tùy chọn để thay đổi loại dữ liệu của các phần tử trong mảng đầu ra:

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

3

Mặc dù đối số nêu rõ

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

62, Numpy diễn giải đây là một

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

63, đây là loại dữ liệu trong Numpy. Bạn có thể xác nhận điều này bằng cách kiểm tra loại một trong các yếu tố của

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

64:

Điều này cho thấy Numpy sử dụng phiên bản riêng của các loại dữ liệu cơ bản. Bạn có thể sử dụng trực tiếp các kiểu dữ liệu Numpy làm đối số cho tham số `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 57:	Điều này tạo ra kết quả đầu ra tương tự nhưng tránh được sự mơ hồ bằng cách nêu rõ kiểu dữ liệu không có.	Khi chọn một loại dữ liệu cụ thể, bạn cần sử dụng thận trọng để đảm bảo rằng không gian tuyến tính của bạn vẫn còn hiệu lực:
Numpy buộc các giá trị là loại `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 66 bằng cách làm tròn theo cách thông thường, nhưng kết quả không còn là một không gian tuyến tính. Nó không chắc rằng đây là kết quả bạn muốn. Bạn có thể đọc thêm về các loại dữ liệu trong Numpy trong tài liệu chính thức.	Các tham số `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 67 và `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 68	Theo mặc định, 1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + stepinterval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) * 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011 9 sử dụng khoảng thời gian đóng, `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 70, trong đó bao gồm điểm cuối. Đây thường là cách sử dụng chức năng này mong muốn của bạn. Tuy nhiên, nếu bạn cần tạo một không gian tuyến tính với khoảng thời gian nửa mở, `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 71, thì bạn có thể đặt tham số Boolean tùy chọn `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 67 thành `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 73:
Tùy chọn này cho phép bạn sử dụng chức năng với quy ước Python không bao gồm điểm cuối với phạm vi.	Hàm cũng có thể xuất kích thước của khoảng giữa các mẫu mà nó tính toán. Nếu bạn cần giá trị của kích thước bước giữa các phần tử, thì bạn có thể đặt tham số Boolean `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 68 thành `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 75:	Giá trị trả về trong trường hợp này là một tuple với mảng là phần tử đầu tiên và nổi với kích thước `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 13 là thứ hai.
Giá trị không quan trọng cho các mảng chiều cao hơn	Bạn cũng có thể sử dụng các giá trị không phân tích cho `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 8 và `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 9. Điều này trả về một mảng chiều cao hơn:	Cả `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 8 và `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 9 đều là danh sách có cùng độ dài. Các mục đầu tiên trong mỗi danh sách, `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 81 và `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 82, là các điểm `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 8 và `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 9 cho vectơ đầu tiên, có các mẫu ____74 được xác định bởi tham số `>>> np.arange(2.34, 31.97, 2) array([ 2.34, 4.34, 6.34, 8.34, 10.34, 12.34, 14.34, 16.34, 18.34, 20.34, 22.34, 24.34, 26.34, 28.34, 30.34])` 6. Điều tương tự áp dụng cho các yếu tố thứ hai từ mỗi danh sách và các yếu tố thứ ba. Đầu ra là một mảng numpy hai chiều với mười hàng và ba cột.
Bạn có thể khám phá mảng này hơn nữa bằng cách kiểm tra một hàng và một phần tử từ mảng hai chiều:	Nếu tham số này được đặt thành `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 75, thì hàm sẽ trả về mảng và `>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 94 với kích thước bước giữa mỗi phần tử của không gian tuyến tính. Nếu không, chỉ có mảng được trả về.	`>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 73
`>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 57	Tham số này có thể được sử dụng để đặt kiểu dữ liệu của các phần tử trong mảng đầu ra.	-
`>>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])` 87	Tham số này chỉ được sử dụng với các giá trị Nonscalar `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 8 và `>>> list(range(2, 30, 2)) [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28] >>> np.arange(2, 30, 2) array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])` 9. Nó xác định trục dọc theo đó kết quả được lưu trữ.	-

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

87

Tham số này chỉ được sử dụng với các giá trị Nonscalar

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9. Nó xác định trục dọc theo đó kết quả được lưu trữ.

Các đầu ra được trả về từ việc gọi chức năng được liệt kê dưới đây:

Một mảng loại

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

2 chứa không gian vectơ

Kích thước bước là >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 94, nếu >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 68 được đặt thành >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 75

Bạn có thể sử dụng phần này làm tài liệu tham khảo khi bạn bắt đầu thử nghiệm với

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 và các cách khác nhau mà bạn có thể tùy chỉnh đầu ra của nó.

Ví dụ: Một băng chuyền sản xuất thực phẩm

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

4

Hãy tưởng tượng rằng một công ty sản xuất các mặt hàng thực phẩm đóng gói có hệ thống băng chuyền trong nhà máy sản xuất thực phẩm. Vị trí dọc theo băng chuyền được tham chiếu bởi một số đại diện cho chiều dài của đường dẫn băng tải từ điểm bắt đầu. Có 27 cảm biến nhiệt độ đã được lắp đặt trong khoảng thời gian bằng nhau dọc theo một đoạn quan trọng của vành đai. Cảm biến đầu tiên được đặt tại vị trí 17.5 dọc theo vành đai và vị trí cuối cùng ở 46.2.

Các mảng cảm biến nhiệt độ đầu ra dữ liệu có thể được đọc dưới dạng danh sách trong Python. Dưới đây, một ví dụ về việc đọc nhiệt độ tính bằng độ C.

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

5

Người quản lý nhà máy cần phải nhìn thấy những nhiệt độ này được vẽ theo vị trí của họ trên băng chuyền để đảm bảo nhiệt độ vẫn ở trong mỗi điểm trên đoạn đường sắt quan trọng này.

Bạn cần phải nhập

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

13 để vẽ nhiệt độ:

Bạn vẽ các giá trị trong danh sách

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

14 và đặt nhãn tiêu đề và trục. Điều này đưa ra cốt truyện sau:

Biểu đồ này cho thấy nhiệt độ được vẽ theo chỉ số danh sách của các cảm biến. Điều này rất hữu ích cho người quản lý nhà máy, người muốn biết nhiệt độ liên quan đến các vị trí tham chiếu tiêu chuẩn của vành đai.
Để tạo một chỉ mục cho nhiệt độ phù hợp với các vị trí tham chiếu đã biết, bạn sẽ sử dụng ba bit thông tin:
Có 27 cảm biến nhiệt độ.

Cái đầu tiên là ở vị trí 17.5.

Cái cuối cùng là ở vị trí 46.2.

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

6

Đây là một kịch bản lý tưởng để sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9:

>>>

Không gian tuyến tính

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

16 cho thấy vị trí chính xác của tất cả các cảm biến nhiệt độ dọc theo băng chuyền. Bây giờ bạn có thể vẽ đồ thị nhiệt độ so với mảng

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

16:

Hướng dẫn how do you evenly space an array in python? - làm thế nào để bạn chia đều một mảng trong python?

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

7

Sự khác biệt so với ví dụ trước trong mã trên là bạn sử dụng mảng >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 16 làm đối số đầu tiên trong >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 19. Điều này đưa ra cốt truyện sau:

Biểu đồ bây giờ hiển thị trục x chính xác, đại diện cho các vị trí mà mỗi nhiệt độ được đo. Ví dụ này cho thấy một trường hợp điển hình mà

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 là giải pháp lý tưởng.discrete representation. One of the key tools you’ll need in this process is the ability to create a linear space.

Đại diện cho các chức năng toán học

Nhiều lĩnh vực khoa học, kỹ thuật, tài chính và các lĩnh vực khác dựa vào các chức năng toán học. Đây thường là các chức năng của các biến liên tục. Nếu bạn muốn nghiên cứu các quy trình này một cách tính toán, thì bạn sẽ cần phải ước tính các chức năng toán học này với một biểu diễn riêng biệt. Một trong những công cụ chính mà bạn sẽ cần trong quá trình này là khả năng tạo không gian tuyến tính.

Chức năng toán học với

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

8

Trong phần này, bạn sẽ học cách biểu diễn một chức năng toán học trong Python và vẽ nó. Xem xét chức năng sau:

Hàm toán học này là một ánh xạ từ dòng số thực liên tục. Ngay cả khi các giới hạn được đặt, giả sử cho -5 x ≤ 5, vẫn còn một số giá trị vô hạn của x. Để thể hiện chức năng ở trên, trước tiên bạn cần tạo một phiên bản riêng biệt của dòng số thực:

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

9

Trong hướng dẫn này, ký hiệu X được sử dụng để biểu diễn biến toán học liên tục được xác định trên dòng số thực và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 được sử dụng để thể hiện xấp xỉ tính toán, riêng biệt của nó. Phiên bản có dấu gạch dưới cũng được sử dụng cho biến Python đại diện cho mảng.

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

0

Vì

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 là một mảng numpy, bạn có thể tính toán các thao tác đại số tương tự như cách bạn sẽ toán học và không cần các vòng lặp:

Mảng mới,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

24, là phiên bản riêng biệt của biến liên tục

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

25. Bước cuối cùng là trực quan hóa nó:undersampled. Doubling the resolution may work better:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1

Điều này đưa ra cốt truyện sau:

Điều đó tốt hơn, và bạn có thể tự tin hơn rằng đó là một đại diện công bằng của chức năng. Tuy nhiên, cốt truyện vẫn không mượt mà như bạn có thể thấy trong một cuốn sách giáo khoa toán học. Với việc lấy mẫu thậm chí cao hơn, cốt truyện trở nên mượt mà hơn:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2

Điều này đưa ra cốt truyện sau:

Bạn có thể chọn một mẫu thậm chí cao hơn, nhưng điều đó sẽ phải trả giá. Các mảng lớn hơn đòi hỏi nhiều bộ nhớ hơn và các tính toán sẽ đòi hỏi nhiều thời gian hơn.

Ví dụ: Sóng du lịch chồng lên

Trong phần này, bạn sẽ tạo ra hai sóng khác nhau với các thuộc tính riêng biệt, sau đó bạn sẽ siêu kích hoạt chúng và tạo một hình ảnh động để cho thấy cách chúng đi du lịch.

Một sóng có thể được biểu diễn bằng toán học bằng hàm sau:

Hướng dẫn này không phải là về vật lý của sóng, vì vậy tôi sẽ giữ vật lý rất ngắn gọn! Một sóng theo hàm hình sin được xác định bởi năm thuật ngữ sau:sinusoidal function that is defined by the following five terms:

Vị trí (x)
Thời gian (t)
Biên độ của sóng (a)
Bước sóng (λ)
Vận tốc của sóng (V)

Bạn sẽ học cách đối phó với các chức năng hai chiều trong phần tiếp theo, nhưng trong ví dụ này, bạn sẽ có một cách tiếp cận khác. Bạn có thể bắt đầu bằng cách tạo một không gian tuyến tính để biểu diễn X:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

3

Khi các hằng số được xác định, bạn có thể tạo sóng. Bạn có thể bắt đầu bằng cách xác định các hằng số:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4

Hàm bao gồm thời gian (t), nhưng ban đầu bạn sẽ tập trung vào biến x. Đặt

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

29 Bây giờ có nghĩa là bạn vẫn có thể viết toàn bộ phương trình trong mã của mình mặc dù bạn chưa sử dụng thời gian. Bây giờ bạn có thể tạo mảng để biểu diễn sóng:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

5

Mảng được tạo là phiên bản riêng biệt của phương trình mô tả sóng. Bây giờ bạn có thể vẽ đồ thị

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

30:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6

Biểu đồ của

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

30 được hiển thị dưới đây:

Điều đó trông giống như một làn sóng hình sin, nhưng bạn đã thấy vấn đề này trước đó. Độ phân giải của không gian tuyến tính được sử dụng cho

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 là đủ. Bạn có thể khắc phục điều này bằng cách tăng lấy mẫu:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

7

Biểu đồ này của

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

30 hiện cho thấy một làn sóng mượt mà:

Bây giờ bạn đã sẵn sàng để siêu nhiều sóng. Tất cả những gì bạn cần làm là tạo hai sóng khác nhau và thêm chúng lên. Đây cũng là thời điểm tốt để tái cấu trúc mã để dọn dẹp nó một chút:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

8

Mã này tạo ra hai sóng khác nhau và thêm chúng lại với nhau, hiển thị sự chồng chất của sóng:

Bạn có thể thấy cả hai sóng được vẽ riêng biệt trong hình trên cùng. Hình dưới cùng cho thấy sự chồng chất của sóng, khi chúng được thêm vào với nhau. Nhiệm vụ cuối cùng của bạn bây giờ là thiết lập các sóng này theo chuyển động bằng cách vẽ các sóng chồng lên nhau cho các giá trị khác nhau của thời gian t:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

9

Điều này cho đầu ra sau:

Bạn có thể thử mã ở trên với các sóng của các tham số khác nhau và thậm chí bạn có thể thêm sóng thứ ba hoặc thứ tư. Bây giờ bạn có thể chọn các chức năng yêu thích của riêng bạn để thử nghiệm và cố gắng đại diện cho chúng trong Python.

Chức năng toán học hai chiều

Trong ví dụ trước, bạn đã giải quyết vấn đề có hàm với hai biến bằng cách biểu diễn một biến là tọa độ không gian và một như một tọa độ thời gian. Điều này có ý nghĩa khi hai tọa độ thực sự là một không gian và một thời gian.

Phương pháp này đã giành chiến thắng luôn luôn làm việc. Ở đây, một chức năng với hai biến:

Đây là hàm Gaussian đơn giản hóa theo hai chiều, với tất cả các tham số có giá trị đơn vị. Để thể hiện điều này, bạn sẽ cần tạo hai không gian tuyến tính, một cho X và một cho y. Trong trường hợp này, chúng có thể giống hệt nhau, nhưng điều đó không cần phải như vậy:

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

0

Các vectơ này là mỗi chiều một chiều, nhưng mảng cần thiết phải là hai chiều vì nó cần thể hiện hàm của hai biến. Numpy có một chức năng hữu ích gọi là

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

34 mà bạn có thể sử dụng kết hợp với

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 để chuyển đổi các vectơ một chiều thành ma trận hai chiều. Các ma trận này đại diện cho các tọa độ theo hai chiều:

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

1

Bạn đã biến các vectơ thành các mảng hai chiều. Bây giờ bạn có thể sử dụng các mảng này để tạo hàm hai chiều:

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

2

Bạn có thể hiển thị ma trận này trong hai hoặc ba chiều bằng cách sử dụng

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

13:

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

3

Các biểu diễn hai chiều và ba chiều được hiển thị bên dưới:

Bạn có thể sử dụng phương pháp này cho bất kỳ chức năng của hai biến. Nếu bạn muốn tạo mặt nạ hình đĩa nhị phân, thì bạn có thể biểu diễn chức năng này bằng các toán tử so sánh:

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

4

Trên dòng 10, bạn tạo ra mảng

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

37 bằng cách sử dụng so sánh phần tử khôn ngoan. Điều này đưa ra cốt truyện sau:

Mảng

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

37 có giá trị

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

75 (hoặc

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8) cho tất cả các giá trị của

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

24 nằm trong phương trình của vòng tròn. Mặt khác, nó có giá trị

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

73 (hoặc

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9).

Bây giờ bạn được trang bị các công cụ để thể hiện các hàm toán học theo một chiều và hai chiều tính toán, sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 để tạo các không gian tuyến tính cần thiết để biểu diễn các biến hàm. Bạn cũng có thể mở rộng khái niệm tương tự đến kích thước cao hơn.

Tạo phạm vi số với khoảng cách không đồng đều

Bạn đã thấy cách tạo và sử dụng một loạt các số cách đều nhau. Tuy nhiên, có những lúc bạn có thể cần một mảng không có khoảng cách tuyến tính. Các bước giữa mỗi giá trị có thể cần phải là logarit hoặc tuân theo một số mẫu khác. Trong phần cuối cùng này, bạn sẽ tìm ra các tùy chọn của bạn là gì để tạo loại mảng này.

Không gian logarit

Hàm

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

46 tạo ra một không gian logarit trong đó các số được tạo đều cách đều nhau trên thang nhật ký.

Khi bạn đã thành thạo

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9, bạn sẽ được trang bị tốt để sử dụng

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

46 vì các tham số đầu vào và đầu ra trả về của hai hàm là rất giống nhau. Một tham số mà Lừa bị thiếu trong

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

46 là

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

68 vì có một giá trị duy nhất để thể hiện bước thay đổi bước giữa các số liên tiếp.

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

46 có tham số đầu vào bổ sung,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

52, với giá trị mặc định là

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4. Một điểm khác biệt quan trọng khác là

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

8 và

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9 đại diện cho điểm bắt đầu và điểm cuối logarit. Giá trị đầu tiên trong mảng là

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

522____68 và giá trị cuối cùng là

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

52

>>> list(range(2, 30, 2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

>>> np.arange(2, 30, 2)
array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

9:

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

5

Điều này tạo ra một không gian logarit với các yếu tố

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

28 từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

64 hoặc từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 đến

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66. Mảng đầu ra cho thấy các số

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8,

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4,

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

82,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

70 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66 trong ký hiệu khoa học. Mặc dù Base 10 là giá trị mặc định, bạn có thể tạo các không gian logarit với bất kỳ cơ sở nào:

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

6

Điều này tạo ra một không gian logarit với các yếu tố

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

28 từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

64 hoặc từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 đến

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66. Mảng đầu ra cho thấy các số

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8,

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4,

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

82,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

70 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66 trong ký hiệu khoa học. Mặc dù Base 10 là giá trị mặc định, bạn có thể tạo các không gian logarit với bất kỳ cơ sở nào:

Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.

Các phạm vi phi tuyến kháctransforming a linear space.

Bây giờ bạn có thể tạo không gian tuyến tính và logarit. Bạn cũng có thể cần một loạt các số theo các khoảng phi tuyến khác. Bạn có thể đạt được điều này bằng cách chuyển đổi một không gian tuyến tính.

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

7

Điều này tạo ra một không gian logarit với các yếu tố

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

28 từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

64 hoặc từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 đến

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66. Mảng đầu ra cho thấy các số

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8,

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4,

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

82,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

70 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66 trong ký hiệu khoa học. Mặc dù Base 10 là giá trị mặc định, bạn có thể tạo các không gian logarit với bất kỳ cơ sở nào:

>>>

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

8

Điều này tạo ra một không gian logarit với các yếu tố

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

28 từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

64 hoặc từ

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8 đến

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66. Mảng đầu ra cho thấy các số

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

8,

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

4,

>>> np.linspace(1, 10, num=10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

82,

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

70 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

66 trong ký hiệu khoa học. Mặc dù Base 10 là giá trị mặc định, bạn có thể tạo các không gian logarit với bất kỳ cơ sở nào:

Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.

Các phạm vi phi tuyến khác

Bây giờ bạn có thể tạo không gian tuyến tính và logarit. Bạn cũng có thể cần một loạt các số theo các khoảng phi tuyến khác. Bạn có thể đạt được điều này bằng cách chuyển đổi một không gian tuyến tính.

Bắt đầu bằng cách tạo một không gian tuyến tính:

Bây giờ bạn có thể chuyển đổi điều này thành một loạt các số tuyến tính trên x2:

Điều này có vẻ quen thuộc. Nó cùng một phương pháp bạn đã sử dụng để đại diện cho các chức năng toán học trước đó trong hướng dẫn này. Thật vậy, nó chính xác giống nhau. Lý do bạn đôi khi có thể muốn nghĩ về điều này vì việc tạo ra một mảng cách đều nhau sẽ trở nên rõ ràng hơn trong phần tiếp theo, khi bạn nhìn vào một ví dụ cụ thể.

>>> step = 20 / 24  # Divide the range into 24 intervals
>>> [-10 + step*interval for interval in range(25)]
[-10.0, -9.166666666666666, -8.333333333333334, -7.5,
 -6.666666666666666, -5.833333333333333, -5.0, -4.166666666666666,
 -3.333333333333333, -2.5, -1.666666666666666, -0.8333333333333321,
 0.0, 0.8333333333333339, 1.6666666666666679, 2.5,
 3.333333333333334, 4.166666666666668, 5.0, 5.833333333333334,
 6.666666666666668, 7.5, 8.333333333333336, 9.166666666666668, 10.0]

9

Ví dụ: Mô phỏng hành tinh quay quanh

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

0

Trong phần này, bạn sẽ tạo ra một mô phỏng của một hành tinh quay quanh mặt trời của nó. Để đơn giản hóa một chút mô phỏng, bạn có thể giả sử quỹ đạo hành tinh là hình tròn chứ không phải là hình elip.

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

1

Phương trình mô tả một vòng tròn là một hàm của x và y và phụ thuộc vào bán kính r:

Vì vậy, nếu các vị trí X của hành tinh được đặt, các vị trí y tương ứng sẽ được đưa ra bằng cách sắp xếp lại phương trình trên:

Do đó, hành tinh có thể được đặt ở một tập hợp các tọa độ (x, y) và miễn là y được cho bởi phương trình trên, hành tinh sẽ vẫn còn trên quỹ đạo. Vị trí của nó sẽ nằm trên chu vi của một vòng tròn.

Bây giờ bạn rất thành thạo với

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9, vì vậy nỗ lực đầu tiên có thể sử dụng các phương pháp bạn đã biết:

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

2

Biến X kéo dài đường kính của vòng tròn dọc theo ngang, từ trái sang phải, có nghĩa là từ -r đến +r. Bây giờ bạn có thể làm việc y:

>>>

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

3

Các giá trị trong

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 đi từ

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

85 đến

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.arange(2.34, 31.97, 2)
array([ 2.34,  4.34,  6.34,  8.34, 10.34, 12.34, 14.34, 16.34, 18.34,
       20.34, 22.34, 24.34, 26.34, 28.34, 30.34])

5 và sau đó trở lại thông qua

>>> np.arange(1.034, 3.104, 0.34)
array([1.034, 1.374, 1.714, 2.054, 2.394, 2.734, 3.074])

>>> np.arange(1.034, 3.104, 0.345)
array([1.034, 1.379, 1.724, 2.069, 2.414, 2.759, 3.104])

9 đến

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

85. Bạn cũng có thể in

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

24 để xác nhận rằng nó tương ứng với các giá trị dương của y cho nửa đầu và các giá trị âm của y cho nửa thứ hai. Một biểu đồ phân tán của

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

24 sẽ xác nhận rằng hành tinh này hiện đang ở trong một quỹ đạo mà một vòng tròn đầy đủ:

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

4

Điều này đưa ra cốt truyện sau:

Bạn đã có thể phát hiện ra vấn đề trong âm mưu phân tán này, nhưng bạn sẽ quay lại với nó một chút sau đó. Hiện tại, bạn có thể sử dụng các vectơ

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 và

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

24 ở trên để tạo mô phỏng hành tinh di chuyển.

Bạn cần phải nhập

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

95 cho việc này:

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

5

Điều này cho đầu ra sau:

Thật không may, các hành tinh don quỹ đạo theo cách này. Bạn có thể thấy hành tinh tăng tốc như thế nào khi nó băng qua trục X ở bên trái và bên phải của quỹ đạo và chậm lại khi nó băng qua trục y ở phía trên và dưới cùng.

Hãy nhìn vào các sơ đồ phân tán cho thấy tất cả các vị trí hành tinh xung quanh quỹ đạo để xem tại sao điều này xảy ra. Các điểm gần nhau hơn ở phía trên và dưới cùng của quỹ đạo nhưng cách nhau ở bên trái và bên phải. Bạn cần các điểm cách đều nhau trên chu vi của quỹ đạo, nhưng những gì bạn có là điểm dựa trên một vectơ

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 đều nhau.

Để khắc phục điều này, bạn cần tạo một mảng các giá trị

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 không tuyến tính nhưng tạo ra các điểm tuyến tính dọc theo chu vi của quỹ đạo. Như một điểm di chuyển trơn tru xung quanh một quỹ đạo tròn, hình chiếu của nó trên các di chuyển trục x (đồng), do đó bạn có thể khắc phục điều này bằng cách thay đổi

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 để nó tuyến tính trên

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

99:

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

6

Dòng đầu tiên biến một không gian tuyến tính thành một không gian phi tuyến. Các khoảng giữa mỗi giá trị của

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 aren bằng nhau nhưng thay đổi tùy theo hàm cosin. Điều này đưa ra cốt truyện sau:

Các điểm bây giờ được đặt cách đều nhau trên chu vi của quỹ đạo tròn. Bước cuối cùng của bạn là tạo lại hình ảnh động bằng cách sử dụng cùng một mã như trước đó. Đây cũng là thời điểm tốt để tăng độ phân giải bằng cách tăng giá trị của biến

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

01 mà bạn đã xác định khi bắt đầu:

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

7

Điều này cho đầu ra sau:

Thật không may, các hành tinh don quỹ đạo theo cách này. Bạn có thể thấy hành tinh tăng tốc như thế nào khi nó băng qua trục X ở bên trái và bên phải của quỹ đạo và chậm lại khi nó băng qua trục y ở phía trên và dưới cùng.

Hãy nhìn vào các sơ đồ phân tán cho thấy tất cả các vị trí hành tinh xung quanh quỹ đạo để xem tại sao điều này xảy ra. Các điểm gần nhau hơn ở phía trên và dưới cùng của quỹ đạo nhưng cách nhau ở bên trái và bên phải. Bạn cần các điểm cách đều nhau trên chu vi của quỹ đạo, nhưng những gì bạn có là điểm dựa trên một vectơ

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 đều nhau.

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

8

Để khắc phục điều này, bạn cần tạo một mảng các giá trị

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 không tuyến tính nhưng tạo ra các điểm tuyến tính dọc theo chu vi của quỹ đạo. Như một điểm di chuyển trơn tru xung quanh một quỹ đạo tròn, hình chiếu của nó trên các di chuyển trục x (đồng), do đó bạn có thể khắc phục điều này bằng cách thay đổi

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

22 để nó tuyến tính trên

>>> np.linspace(-10, 10, 25)
array([-10.        ,  -9.16666667,  -8.33333333,  -7.5       ,
        -6.66666667,  -5.83333333,  -5.        ,  -4.16666667,
        -3.33333333,  -2.5       ,  -1.66666667,  -0.83333333,
         0.        ,   0.83333333,   1.66666667,   2.5       ,
         3.33333333,   4.16666667,   5.        ,   5.83333333,
         6.66666667,   7.5       ,   8.33333333,   9.16666667,
        10.        ])

99:

Dòng đầu tiên biến một không gian tuyến tính thành một không gian phi tuyến. Các khoảng giữa mỗi giá trị của >>> np.linspace(-10, 10, 25) array([-10. , -9.16666667, -8.33333333, -7.5 , -6.66666667, -5.83333333, -5. , -4.16666667, -3.33333333, -2.5 , -1.66666667, -0.83333333, 0. , 0.83333333, 1.66666667, 2.5 , 3.33333333, 4.16666667, 5. , 5.83333333, 6.66666667, 7.5 , 8.33333333, 9.16666667, 10. ]) 22 aren bằng nhau nhưng thay đổi tùy theo hàm cosin. Điều này đưa ra cốt truyện sau:

Các điểm bây giờ được đặt cách đều nhau trên chu vi của quỹ đạo tròn. Bước cuối cùng của bạn là tạo lại hình ảnh động bằng cách sử dụng cùng một mã như trước đó. Đây cũng là thời điểm tốt để tăng độ phân giải bằng cách tăng giá trị của biến

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

01 mà bạn đã xác định khi bắt đầu:

Để xem phiên bản đầy đủ của mã tạo hoạt hình này, bạn có thể mở rộng phần bên dưới.

Phiên bản đầy đủ, cuối cùng của mô phỏng, bao gồm lưu mô phỏng vào

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

02, có sẵn ở đây:

Bạn chỉ tạo ra một hình ảnh động của một hành tinh quay quanh một ngôi sao. Bạn phải thực hiện chuyển động của hành tinh tuyến tính trên chu vi của một vòng tròn bằng cách tạo các vị trí của hành tinh cách đều nhau trên chu vi của vòng tròn. Bây giờ bạn có thể tạo bất kỳ phạm vi số không đều nhau nào miễn là bạn có thể diễn đạt nó về mặt toán học.range of numbers

Sự kết luận
1>>> import timeit 2>>> import numpy as np 3>>> numbers_array = np.linspace(-10, 10, 500) 4>>> step = 20 / 499 5>>> numbers_list = [-10 + step*interval for interval in range(500)] 6>>> def test_np(): 7... return (numbers_array + 2.5) ** 2 8... 9>>> def test_list(): 10... return [(number + 2.5) ** 2 for number in numbers_list] 11... 12>>> list(test_np()) == test_list() 13True 14>>> timeit.timeit("test_np()", globals=globals(), number=100000) 150.3116540400000076 16>>> timeit.timeit("test_list()", globals=globals(), number=100000) 175.478577034000011
9 instead of alternative tools

Tạo ra một loạt các số trong Python dường như không phức tạp trên bề mặt, nhưng như bạn đã thấy trong hướng dẫn này, bạn có thể sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 theo nhiều cách. Nhiều ứng dụng số trong khoa học, kỹ thuật, toán học, tài chính, kinh tế và các lĩnh vực tương tự sẽ khó thực hiện hơn nhiều nếu không có lợi ích của sự nhảm nhí và khả năng tạo ra một phạm vi số đồng đều hoặc không đồng đều.input parameters

Biết cách sử dụng

 1>>> import timeit
 2>>> import numpy as np
 3>>> numbers_array = np.linspace(-10, 10, 500)
 4>>> step = 20 / 499
 5>>> numbers_list = [-10 + step*interval for interval in range(500)]
 6>>> def test_np():
 7...     return (numbers_array + 2.5) ** 2
 8...
 9>>> def test_list():
10...     return [(number + 2.5) ** 2 for number in numbers_list]
11...
12>>> list(test_np()) == test_list()
13True
14>>> timeit.timeit("test_np()", globals=globals(), number=100000)
150.3116540400000076
16>>> timeit.timeit("test_list()", globals=globals(), number=100000)
175.478577034000011

9 và biết cách sử dụng tốt, sẽ cho phép bạn làm việc thông qua các ứng dụng lập trình số một cách hiệu quả.two or more dimensions

Trong hướng dẫn này, bạn đã học được cách:mathematical functions in discrete form

Tạo một phạm vi số đồng đều hoặc không đồng đều

Hàm Numpy được sử dụng để tạo ra các mảng cách đều nhau là gì?

Không gian linsp không gian tạo ra các chuỗi các giá trị cách đều nhau trong một khoảng thời gian.Hàm không gian linsp không gian tạo ra các chuỗi các giá trị cách đều nhau trong một khoảng thời gian xác định. creates sequences of evenly spaced values within an interval. The NumPy linspace function creates sequences of evenly spaced values within a defined interval.

Bạn có thể thay đổi kích thước mảng trong Python không?

Với sự trợ giúp của numpy numpy.resize (), chúng ta có thể thay đổi kích thước của một mảng.Mảng có thể có bất kỳ hình dạng nào nhưng để thay đổi kích thước nó, chúng ta chỉ cần kích thước tức là (2, 2), (2, 3) và nhiều hơn nữa. resize(), we can resize the size of an array. Array can be of any shape but to resize it we just need the size i.e (2, 2), (2, 3) and many more.

Linspace hoạt động như thế nào?

Hàm Linspace () trả về các số cách đều nhau trong một khoảng thời gian được chỉ định [START, STOP].Điểm cuối của khoảng thời gian có thể được loại trừ tùy ý.Giá trị bắt đầu của chuỗi.Giá trị cuối của chuỗi, trừ khi điểm cuối được đặt thành sai.returns evenly spaced numbers over a specified interval [start, stop]. The endpoint of the interval can optionally be excluded. The starting value of the sequence. The end value of the sequence, unless endpoint is set to False.

Bạn có thể chia một mảng trong Python không?

Python's numpy.divide () tính toán sự phân chia phần tử của các phần tử mảng.Các phần tử trong mảng thứ nhất được chia cho các phần tử trong mảng thứ hai. divide() computes the element-wise division of array elements. The elements in the first array are divided by the elements in the second array.

programming python Linspace MATLAB Np linspace meaning Python equal spacing np.linspace là gì Linspace Python

Hướng dẫn how do you evenly space an array in python? - làm thế nào để bạn chia đều một mảng trong python?

Tạo phạm vi số lượng với khoảng cách thậm chí

Sử dụng >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 05

Ở đây, một quy tắc tốt để quyết định sử dụng chức năng nào trong hai chức năng:

Tham số >>> np.linspace(1, 10, num=10) array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]) 57 để thay đổi loại đầu ra

Đại diện cho các chức năng toán học

Ví dụ: Sóng du lịch chồng lên

Chức năng toán học hai chiều

Tạo phạm vi số với khoảng cách không đồng đều

Không gian logarit

Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.

Ví dụ này cho thấy một không gian logarit trong cơ sở e. Trong phần tiếp theo, bạn sẽ thấy cách tạo các phạm vi phi tuyến khác mà aren logarit.

Hàm Numpy được sử dụng để tạo ra các mảng cách đều nhau là gì?

Bạn có thể thay đổi kích thước mảng trong Python không?

Linspace hoạt động như thế nào?

Bạn có thể chia một mảng trong Python không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội