{"id":3788,"date":"2026-01-24T10:16:59","date_gmt":"2026-01-24T10:16:59","guid":{"rendered":"https:\/\/www.askpython.com\/?p=3788"},"modified":"2026-01-25T14:56:01","modified_gmt":"2026-01-25T14:56:01","slug":"numpy-linspace-python","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python-modules\/numpy\/numpy-linspace-python","title":{"rendered":"NumPy linspace(): Create Arrays Fast"},"content":{"rendered":"
\nimport numpy as np\n\n# Create 5 evenly spaced values between 0 and 10\nresult = np.linspace(0, 10, 5)\nprint(result)\n# Output: [ 0.   2.5  5.   7.5 10. ]\n\n<\/pre><\/div>\n\n\n
The np.linspace function generates evenly spaced numbers across a defined interval. You specify where to start, where to stop, and how many values you want. NumPy calculates the spacing automatically.<\/p>\n\n\n\n
Basic syntax for np.linspace<\/h2>\n\n\n\n
The function accepts several parameters that control array generation:<\/p>\n\n\n
\nnumpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)\n\n<\/pre><\/div>\n\n\n
The start parameter defines your first value. The stop parameter sets your last value (or the boundary if endpoint is False). The num parameter determines how many values to generate between these boundaries.<\/p>\n\n\n
\nimport numpy as np\n\n# Generate 10 values from 0 to 100\nvalues = np.linspace(0, 100, 10)\nprint(values)\n# Output: [  0.  11.11111111  22.22222222  33.33333333  44.44444444  \n#           55.55555556  66.66666667  77.77777778  88.88888889 100.]\n\n<\/pre><\/div>\n\n\n
NumPy divides the interval into equal segments. With 10 values spanning 0 to 100, each step measures approximately 11.11 units. The function includes both endpoints by default, which affects the spacing calculation.<\/p>\n\n\n\n
Understanding the endpoint parameter in np.linspace<\/h2>\n\n\n\n
The endpoint parameter changes how np.linspace calculates spacing. When endpoint equals True (the default), the stop value appears in your output array. When endpoint equals False, NumPy excludes the stop value and adjusts the spacing.<\/p>\n\n\n
\nimport numpy as np\n\n# With endpoint included\nincluded = np.linspace(0, 10, 5, endpoint=True)\nprint("Endpoint included:", included)\n# Output: [ 0.   2.5  5.   7.5 10. ]\n\n# Without endpoint\nexcluded = np.linspace(0, 10, 5, endpoint=False)\nprint("Endpoint excluded:", excluded)\n# Output: [0. 2. 4. 6. 8.]\n\n<\/pre><\/div>\n\n\n
Notice how the spacing changes. With the endpoint included, you get values at 0, 2.5, 5, 7.5, and 10. Without the endpoint, the spacing becomes 2.0 instead of 2.5, and the array stops at 8.<\/p>\n\n\n\n
This behavior matters when you need precise control over array boundaries. For periodic functions or when creating bins for histograms, excluding the endpoint often produces cleaner results.<\/p>\n\n\n
\nimport numpy as np\n\n# Creating bins for a histogram\nbins = np.linspace(0, 100, 11, endpoint=False)\nprint(bins)\n# Output: [ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90.]\n\n<\/pre><\/div>\n\n\n
Getting step size with the retstep parameter<\/h2>\n\n\n\n
The retstep parameter returns both the array and the spacing between values. This becomes useful when you need to know the exact step size for subsequent calculations.<\/p>\n\n\n
\nimport numpy as np\n\n# Get array and step size\narray, step = np.linspace(0, 50, 11, retstep=True)\nprint("Array:", array)\nprint("Step size:", step)\n# Output:\n# Array: [ 0.  5. 10. 15. 20. 25. 30. 35. 40. 45. 50.]\n# Step size: 5.0\n\n<\/pre><\/div>\n\n\n
The function returns a tuple when retstep is True. You can unpack this tuple directly into two variables, as shown above. The step value represents the distance between consecutive elements.<\/p>\n\n\n
\nimport numpy as np\n\n# Using step size for calculations\nvalues, spacing = np.linspace(1, 100, 20, retstep=True)\nnext_value = values[-1] + spacing\nprint(f"Next value in sequence: {next_value}")\n# Output: Next value in sequence: 105.21052631578948\n\n<\/pre><\/div>\n\n\n
Creating arrays for plotting with np.linspace<\/h2>\n\n\n\n
Plotting functions requires x-axis values with sufficient resolution to show smooth curves. The np.linspace method excels at generating these coordinate arrays.<\/p>\n\n\n
\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Generate x values for a sine wave\nx = np.linspace(0, 2 * np.pi, 100)\ny = np.sin(x)\n\nplt.plot(x, y)\nplt.title('Sine wave using np.linspace')\nplt.xlabel('x')\nplt.ylabel('sin(x)')\nplt.grid(True)\nplt.show()\n\n<\/pre><\/div>\n\n\n
The code above creates 100 evenly spaced points between 0 and 2\u03c0. More points produce smoother curves but require more computation. Fewer points run faster but create jagged lines.<\/p>\n\n\n
\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Compare different resolutions\nx_low = np.linspace(0, 2 * np.pi, 10)\nx_high = np.linspace(0, 2 * np.pi, 200)\n\nplt.plot(x_low, np.sin(x_low), 'o-', label='10 points')\nplt.plot(x_high, np.sin(x_high), label='200 points')\nplt.legend()\nplt.show()\n\n<\/pre><\/div>\n\n\n
You can also create custom x-axis scales for specialized plots. If your data represents temperature sensors along a conveyor belt, np.linspace generates the position values.<\/p>\n\n\n
\nimport numpy as np\n\n# Position of 15 sensors from 0 to 100 meters\nsensor_positions = np.linspace(0, 100, 15)\ntemperatures = np.random.uniform(20, 30, 15)  # Random temps\n\nfor pos, temp in zip(sensor_positions, temperatures):\n    print(f"Position {pos:.2f}m: {temp:.2f}\u00b0C")\n\n<\/pre><\/div>\n\n\n
Evaluating mathematical functions using np.linspace<\/h2>\n\n\n\n
Mathematical functions operate on continuous domains, but computers work with discrete values. The np.linspace function bridges this gap by sampling functions at regular intervals.<\/p>\n\n\n
\nimport numpy as np\n\n# Evaluate a quadratic function\nx = np.linspace(-5, 5, 50)\ny = x**2 - 3*x + 2\n\nprint(f"Minimum value: {np.min(y):.4f}")\nprint(f"Maximum value: {np.max(y):.4f}")\n# Output varies based on sampling, but captures the function's behavior\n\n<\/pre><\/div>\n\n\n
You can combine multiple functions for complex calculations. NumPy’s vectorized operations work directly on arrays generated by np.linspace.<\/p>\n\n\n
\nimport numpy as np\n\n# Calculate compound interest over time\nprincipal = 1000\nrate = 0.05\nyears = np.linspace(0, 30, 31)  # 0 to 30 years\n\nbalance = principal * np.exp(rate * years)\n\nprint("Year 0:", balance[0])\nprint("Year 10:", balance[10])\nprint("Year 30:", balance[30])\n\n<\/pre><\/div>\n\n\n
The exponential function np.exp applies to every element in the years array. This produces a balance array showing compound growth at each time step. No loops required.<\/p>\n\n\n\n
Building multidimensional arrays with np.linspace<\/h2>\n\n\n\n
You can transform one-dimensional linspace arrays into higher dimensions using reshape or by creating coordinate grids.<\/p>\n\n\n
\nimport numpy as np\n\n# Create a 2D grid\nx = np.linspace(0, 1, 25).reshape(5, 5)\nprint(x)\n\n<\/pre><\/div>\n\n\n
For genuine 2D coordinate systems, combine np.linspace with np.meshgrid. This creates coordinate matrices for evaluating functions of two variables.<\/p>\n\n\n
\nimport numpy as np\n\n# Create 2D coordinate system\nx = np.linspace(-2, 2, 50)\ny = np.linspace(-2, 2, 50)\nX, Y = np.meshgrid(x, y)\n\n# Evaluate 2D Gaussian\nZ = np.exp(-(X**2 + Y**2))\n\nprint(f"Grid shape: {Z.shape}")\nprint(f"Maximum value: {np.max(Z):.4f}")\n\n<\/pre><\/div>\n\n\n
The meshgrid function transforms two 1D arrays into two 2D matrices. Each matrix contains coordinates for evaluating functions across the grid. This technique powers 3D surface plots and contour maps.<\/p>\n\n\n
\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Create saddle surface\nx = np.linspace(-3, 3, 100)\ny = np.linspace(-3, 3, 100)\nX, Y = np.meshgrid(x, y)\nZ = X**2 - Y**2\n\nplt.contourf(X, Y, Z, levels=20, cmap='viridis')\nplt.colorbar()\nplt.title('Saddle surface: z = x\u00b2 - y\u00b2')\nplt.show()\n\n<\/pre><\/div>\n\n\n
Controlling data types with the dtype parameter<\/h2>\n\n\n\n
The dtype parameter specifies the data type for array elements. NumPy infers float64 by default when you provide floating-point start or stop values.<\/p>\n\n\n
\nimport numpy as np\n\n# Default float type\nfloats = np.linspace(0, 10, 5)\nprint(f"Type: {floats.dtype}")\n# Output: Type: float64\n\n# Force integer type\nintegers = np.linspace(0, 10, 5, dtype=int)\nprint(f"Type: {integers.dtype}")\nprint(integers)\n# Output: Type: int64\n# [ 0  2  5  7 10]\n\n<\/pre><\/div>\n\n\n
Integer conversion truncates decimal values toward negative infinity. This can create unexpected results when you expect rounding.<\/p>\n\n\n
\nimport numpy as np\n\n# Compare conversion methods\nfloat_array = np.linspace(0, 10, 11)\nint_direct = np.linspace(0, 10, 11, dtype=int)\nint_rounded = np.round(float_array).astype(int)\n\nprint("Float array:", float_array)\nprint("Direct int:", int_direct)\nprint("Rounded int:", int_rounded)\n\n<\/pre><\/div>\n\n\n
You can specify any NumPy dtype: float32, complex128, or custom structured types. Lower precision types save memory but reduce accuracy.<\/p>\n\n\n
\nimport numpy as np\n\n# Memory comparison\nfloat64_array = np.linspace(0, 100, 1000, dtype=np.float64)\nfloat32_array = np.linspace(0, 100, 1000, dtype=np.float32)\n\nprint(f"Float64 memory: {float64_array.nbytes} bytes")\nprint(f"Float32 memory: {float32_array.nbytes} bytes")\n# Float64 uses 8000 bytes, Float32 uses 4000 bytes\n\n<\/pre><\/div>\n\n\n
Comparing np.linspace vs np.arange<\/h2>\n\n\n\n
NumPy provides np.arange for creating sequences with fixed step sizes. Understanding when to use each function saves debugging time.<\/p>\n\n\n\n
The np.linspace function prioritizes endpoint precision. You specify exactly where to start and stop, plus how many values you need. NumPy calculates the step size.<\/p>\n\n\n
\nimport numpy as np\n\n# Using linspace\nlin = np.linspace(0, 1, 11)\nprint("Linspace:", lin)\n# Output: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n\n<\/pre><\/div>\n\n\n
The np.arange function prioritizes step size. You specify the increment between values, and NumPy generates values until reaching (but not including) the stop value.<\/p>\n\n\n
\nimport numpy as np\n\n# Using arange\narr = np.arange(0, 1.1, 0.1)\nprint("Arange:", arr)\n# Output: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n\n<\/pre><\/div>\n\n\n
These look similar but behave differently with non-integer steps. Floating-point arithmetic in np.arange can produce unexpected results.<\/p>\n\n\n
\nimport numpy as np\n\n# Arange with floating-point step\nproblematic = np.arange(0, 1, 0.3)\nprint("Arange with 0.3 step:", problematic)\nprint("Length:", len(problematic))\n# Output might have 3 or 4 elements depending on rounding errors\n\n<\/pre><\/div>\n\n\n
Use np.linspace when you need exact start and stop values, especially for plotting or mathematical analysis. Use np.arange when the step size matters more than the endpoint, particularly with integer sequences.<\/p>\n\n\n\n
Practical use cases for np.linspace in data science<\/h2>\n\n\n\n
Time series analysis often requires evenly spaced timestamps. The np.linspace function creates these temporal arrays for resampling or interpolation.<\/p>\n\n\n
\nimport numpy as np\nimport pandas as pd\n\n# Create hourly timestamps for a day\nhours = np.linspace(0, 24, 25)\ntimestamps = pd.date_range('2024-01-01', periods=25, freq='h')\n\n# Simulate temperature readings\ntemperatures = 20 + 5 * np.sin(2 * np.pi * hours \/ 24)\n\ndf = pd.DataFrame({\n    'timestamp': timestamps,\n    'temperature': temperatures\n})\nprint(df.head())\n\n<\/pre><\/div>\n\n\n
Machine learning models sometimes need synthetic data for testing. You can generate evenly distributed features using np.linspace.<\/p>\n\n\n
\nimport numpy as np\n\n# Generate synthetic linear regression data\nX = np.linspace(0, 10, 100).reshape(-1, 1)\nnoise = np.random.normal(0, 1, 100).reshape(-1, 1)\ny = 3 * X + 5 + noise\n\nprint(f"Feature shape: {X.shape}")\nprint(f"Target shape: {y.shape}")\n\n<\/pre><\/div>\n\n\n
Signal processing applications use np.linspace to create time arrays for sampling continuous signals at specific frequencies.<\/p>\n\n\n
\nimport numpy as np\n\n# Sample rate of 44.1 kHz (CD quality)\nsample_rate = 44100\nduration = 1.0  # seconds\n\n# Create time array\nt = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)\n\n# Generate 440 Hz tone (musical note A)\nfrequency = 440\nsignal = np.sin(2 * np.pi * frequency * t)\n\nprint(f"Signal length: {len(signal)} samples")\nprint(f"Signal duration: {duration} seconds")\n\n<\/pre><\/div>\n\n\n
The endpoint=False parameter prevents creating a sample at exactly 1.0 seconds, which would duplicate the start of the next period in continuous playback.<\/p>\n\n\n\n
Common patterns and edge cases with np.linspace<\/h2>\n\n\n\n
Single-value arrays serve as edge cases. When num equals 1, np.linspace returns the start value.<\/p>\n\n\n
\nimport numpy as np\n\nsingle = np.linspace(5, 10, 1)\nprint(single)\n# Output: [5.]\n\n<\/pre><\/div>\n\n\n
Empty arrays result from num=0. This creates a valid NumPy array with zero elements.<\/p>\n\n\n
\nimport numpy as np\n\nempty = np.linspace(0, 10, 0)\nprint(empty)\nprint(f"Length: {len(empty)}")\n# Output: []\n# Length: 0\n\n<\/pre><\/div>\n\n\n
Negative ranges work identically to positive ranges. The function simply creates evenly spaced values in reverse order.<\/p>\n\n\n
\nimport numpy as np\n\nnegative = np.linspace(10, 0, 11)\nprint(negative)\n# Output: [10.  9.  8.  7.  6.  5.  4.  3.  2.  1.  0.]\n\n<\/pre><\/div>\n\n\n
Complex number ranges follow the same logic, spacing values in the complex plane.<\/p>\n\n\n
\nimport numpy as np\n\ncomplex_range = np.linspace(0+0j, 1+1j, 5)\nprint(complex_range)\n# Output: [0.  +0.j   0.25+0.25j 0.5 +0.5j  0.75+0.75j 1.  +1.j  ]\n\n<\/pre><\/div>\n\n\n
The np.linspace function handles these edge cases consistently. The same spacing algorithm applies regardless of value types or ranges.<\/p>\n\n\n\n
Performance considerations for np.linspace arrays<\/h2>\n\n\n\n
Large arrays consume memory proportionally to their size. A million-element float64 array requires about 8 megabytes.<\/p>\n\n\n
\nimport numpy as np\n\n# Create large array\nlarge = np.linspace(0, 1, 1_000_000)\nprint(f"Memory usage: {large.nbytes \/ 1024 \/ 1024:.2f} MB")\n# Output: Memory usage: 7.63 MB\n\n<\/pre><\/div>\n\n\n
Generation speed scales linearly with array size. Creating 10 million elements takes roughly 10 times longer than 1 million elements.<\/p>\n\n\n
\nimport numpy as np\nimport time\n\nsizes = [1_000, 10_000, 100_000, 1_000_000]\n\nfor size in sizes:\n    start = time.time()\n    arr = np.linspace(0, 1, size)\n    elapsed = time.time() - start\n    print(f"Size {size}: {elapsed*1000:.4f} ms")\n\n<\/pre><\/div>\n\n\n
For extremely large arrays, consider generating values on demand rather than storing everything in memory. Generator expressions or chunked processing save resources.<\/p>\n\n\n\n
The np.linspace method remains one of NumPy’s most versatile functions. It creates evenly spaced arrays for plotting, mathematical analysis, signal processing, and scientific computing. The function’s simplicity conceals its power. You specify boundaries and count, and NumPy handles the rest. Master this function and you unlock precise numerical control across countless applications.<\/p>\n","protected":false},"excerpt":{"rendered":"
The np.linspace function generates evenly spaced numbers across a defined interval. You specify where to start, where to stop, and how many values you want. NumPy calculates the spacing automatically. Basic syntax for np.linspace The function accepts several parameters that control array generation: The start parameter defines your first value. The stop parameter sets your […]<\/p>\n","protected":false},"author":6,"featured_media":65731,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[93],"tags":[],"class_list":["post-3788","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-numpy"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/3788","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=3788"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/3788\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/65731"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=3788"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=3788"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=3788"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}