NumPy Arange: 균등 간격 값을 가진 배열을 생성하는 방법

Name

Soren Atelier

Updated on 2026. 2. 9.

균등 간격의 숫자 배열을 생성하는 것은 과학 컴퓨팅, 데이터 분석, 머신러닝에서 가장 일반적인 작업 중 하나입니다. 루프를 위한 인덱스 시퀀스, 그래프를 위한 X축 값, 시뮬레이션을 위한 격자 좌표가 필요하든, 빠르고 신뢰할 수 있는 생성 방법이 필요합니다. Python의 내장 range() 함수는 정수에 대해서는 작동하지만, 부동소수점 스텝이 필요하거나 벡터화된 연산을 위해 NumPy 배열로 결과가 필요할 때는 한계가 있습니다.

바로 이것을 해결하는 것이 numpy.arange() 입니다. 시작점, 종료점, 스텝 크기, 데이터 타입을 완전히 제어하면서 균등 간격 값의 배열을 단일 함수 호출로 생성합니다. 이 가이드는 모든 매개변수를 다루고, 실용적인 예제를 제시하며, np.arange()를 range()와 np.linspace() 같은 대안과 비교하고, 가장 흔한 실수를 피하는 방법을 보여줍니다.

np.arange()가 하는 일

np.arange()는 주어진 구간 내에서 균등 간격의 값을 포함하는 1차원 NumPy 배열을 반환합니다. Python의 range()에 대응하는 NumPy 함수이지만, range 객체 대신 ndarray를 반환하고 부동소수점 숫자를 지원합니다.

전체 함수 시그니처는 다음과 같습니다:

numpy.arange([start, ] stop, [step, ] dtype=None)

매개변수 참조

이 함수는 start에서 시작하여 step만큼 증가하면서 값을 생성하고, stop에 도달하기 전에 멈춥니다. 이 "배타적 stop" 동작은 Python의 range()와 일치합니다.

기본 사용법: Stop 값만 지정

np.arange()를 사용하는 가장 간단한 방법은 하나의 인수만 전달하는 것입니다. 하나의 값을 전달하면 stop으로 처리되고, start는 기본값 0, step은 1이 됩니다.

import numpy as np
 
arr = np.arange(5)
print(arr)
# Output: [0 1 2 3 4]
 
print(type(arr))
# Output: <class 'numpy.ndarray'>

이것은 0부터 5 미만까지의 정수 배열을 생성합니다. 결과가 Python 리스트가 아닌 NumPy ndarray라는 점에 주목하세요. 즉, 벡터화된 연산에 바로 사용할 수 있습니다:

import numpy as np
 
arr = np.arange(5)
print(arr * 10)
# Output: [ 0 10 20 30 40]
 
print(arr ** 2)
# Output: [ 0  1  4  9 16]

Start와 Stop 사용

두 개의 인수를 전달하여 시퀀스의 시작과 끝을 제어합니다:

import numpy as np
 
arr = np.arange(2, 10)
print(arr)
# Output: [2 3 4 5 6 7 8 9]

배열은 2(포함)에서 시작하고 10(미포함) 전에 멈춥니다. 기본 스텝은 여전히 1입니다.

음수 시작 값도 사용할 수 있습니다:

import numpy as np
 
arr = np.arange(-3, 4)
print(arr)
# Output: [-3 -2 -1  0  1  2  3]

Start, Stop, Step 사용

세 번째 인수는 값 사이의 간격을 제어합니다. 여기서 np.arange()가 range()보다 훨씬 강력해지는데, 스텝이 부동소수점 수가 될 수 있기 때문입니다:

import numpy as np
 
arr = np.arange(0, 1, 0.1)
print(arr)
# Output: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

정수 스텝도 같은 방식으로 작동합니다:

import numpy as np
 
arr = np.arange(0, 20, 3)
print(arr)
# Output: [ 0  3  6  9 12 15 18]

스텝은 어떤 양수든 될 수 있습니다. 시퀀스는 항상 stop 값에 도달하기 전에 멈춥니다.

부동소수점 스텝 크기와 정밀도 문제

부동소수점 스텝 크기를 사용하는 것은 편리하지만 주의할 점이 있습니다: 부동소수점 산술은 정확하지 않습니다. 작은 반올림 오류가 축적되어 때때로 예상치 못한 결과를 만들 수 있습니다.

다음 예제를 살펴보세요:

import numpy as np
 
arr = np.arange(0, 1, 0.3)
print(arr)
# Output: [0.  0.3 0.6 0.9]
 
print(len(arr))
# Output: 4

이것은 올바르게 보입니다. 하지만 특정 스텝 크기에서 어떤 일이 발생하는지 살펴보세요:

import numpy as np
 
arr = np.arange(0, 1.0, 0.1)
print(len(arr))
# Output: 10
 
arr2 = np.arange(0.0, 1.0 + 1e-10, 0.1)
print(len(arr2))
# Output: 11

부동소수점 표현으로 인해 이진수에서 0.1 * 10이 정확히 1.0과 같지 않을 수 있습니다. 결과의 요소 수는 특정 값에 따라 하나 차이가 날 수 있습니다.

모범 사례: 정확한 수의 균등 간격 부동소수점 값이 필요할 때는 대신 np.linspace()를 사용하세요. np.arange()는 정확한 요소 수가 중요하지 않을 때만 부동소수점 시퀀스에 사용하세요.

음수 스텝: 카운트다운

음수 step을 설정하여 내림차순 시퀀스를 생성합니다:

import numpy as np
 
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

부동소수점 스텝도 같은 방식으로 작동합니다:

import numpy as np
 
arr = np.arange(2.0, 0.0, -0.5)
print(arr)
# Output: [2.  1.5 1.  0.5]

핵심 규칙: 스텝 방향은 start에서 stop으로의 방향과 일치해야 합니다. start < stop이면 스텝은 양수여야 합니다. start > stop이면 스텝은 음수여야 합니다. 이를 잘못 지정하면 빈 배열이 생성됩니다(아래 오류 섹션에서 다룹니다).

dtype 매개변수

기본적으로 np.arange()는 전달된 인수에서 데이터 타입을 추론합니다. 모든 인수가 정수이면 정수 배열을 얻습니다. 인수 중 하나가 부동소수점이면 부동소수점 배열을 얻습니다. dtype 매개변수를 사용하여 이를 재정의할 수 있습니다:

import numpy as np
 
# Default: integers in, integers out
arr_int = np.arange(5)
print(arr_int.dtype)
# Output: int64
 
# Default: float step, float output
arr_float = np.arange(0, 5, 0.5)
print(arr_float.dtype)
# Output: float64
 
# Force float output from integer inputs
arr_forced = np.arange(5, dtype=np.float32)
print(arr_forced)
# Output: [0. 1. 2. 3. 4.]
print(arr_forced.dtype)
# Output: float32
 
# Force integer output (values get truncated)
arr_trunc = np.arange(0, 2, 0.5, dtype=int)
print(arr_trunc)
# Output: [0 0 1 1]

마지막 예제에 주목하세요: 부동소수점 시퀀스에 정수 dtype을 강제하면 각 값이 반올림되는 것이 아니라 절삭됩니다. 이로 인해 중복 값과 예상치 못한 결과가 발생할 수 있으므로 주의하여 사용하세요.

np.arange() vs range(): 각각의 사용 시점

Python의 내장 range()와 NumPy의 np.arange()는 모두 숫자 시퀀스를 생성하지만 서로 다른 목적으로 사용됩니다.

range()를 사용할 때: 인덱스가 필요하고 시퀀스 자체에 대한 연산을 하지 않는 순수 Python 루프.

np.arange()를 사용할 때: 결과가 수치 계산에 사용되거나, NumPy/SciPy 함수에 전달되거나, 부동소수점 값을 포함해야 하는 모든 경우.

import numpy as np
 
# range() for loop iteration
for i in range(5):
    print(i, end=' ')
# Output: 0 1 2 3 4
 
print()
 
# np.arange() for vectorized math
x = np.arange(5)
print(np.sin(x))
# Output: [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025 ]

np.arange() vs np.linspace(): 각각의 사용 시점

두 함수 모두 균등 간격 값의 배열을 생성하지만, 간격을 정의하는 방식이 다릅니다.

차이를 명확히 보여주는 비교 예제입니다:

import numpy as np
 
# arange: "give me values from 0 to 1, stepping by 0.2"
a = np.arange(0, 1, 0.2)
print(f"arange: {a}  (length: {len(a)})")
# Output: arange: [0.  0.2 0.4 0.6 0.8]  (length: 5)
 
# linspace: "give me exactly 6 values from 0 to 1"
b = np.linspace(0, 1, 6)
print(f"linspace: {b}  (length: {len(b)})")
# Output: linspace: [0.  0.2 0.4 0.6 0.8 1. ]  (length: 6)

np.linspace()는 끝점(1.0)을 포함하고 정확히 6개의 값을 보장하는 반면, np.arange()는 1.0 전에 멈추고 카운트는 부동소수점 스텝 계산에 의존합니다.

경험 법칙: 스텝 크기가 중요할 때는 np.arange()를 사용하세요. 포인트 수가 중요할 때는 np.linspace()를 사용하세요.

일반적인 사용 사례

루프 인덱스와 배열 인덱싱

import numpy as np
 
data = np.array([10, 20, 30, 40, 50])
indices = np.arange(len(data))
 
print(indices)
# Output: [0 1 2 3 4]
 
# Use for conditional selection
mask = indices % 2 == 0
print(data[mask])
# Output: [10 30 50]

그래프용 X축 값

import numpy as np
 
x = np.arange(0, 2 * np.pi, 0.01)
y = np.sin(x)
 
print(f"x has {len(x)} points, from {x[0]:.2f} to {x[-1]:.2f}")
# Output: x has 629 points, from 0.00 to 6.28
print(f"y ranges from {y.min():.4f} to {y.max():.4f}")
# Output: y ranges from -1.0000 to 1.0000

x와 y를 matplotlib의 plt.plot(x, y)에 직접 전달하여 매끄러운 사인파를 그릴 수 있습니다.

격자 좌표 생성

import numpy as np
 
x = np.arange(0, 3)
y = np.arange(0, 4)
xx, yy = np.meshgrid(x, y)
 
print("xx:")
print(xx)
# Output:
# [[0 1 2]
#  [0 1 2]
#  [0 1 2]
#  [0 1 2]]
 
print("yy:")
print(yy)
# Output:
# [[0 0 0]
#  [1 1 1]
#  [2 2 2]
#  [3 3 3]]

이 패턴은 이미지 처리, 히트맵, 3D 표면 그래프에서 광범위하게 사용됩니다.

시간 기반 시퀀스 생성

import numpy as np
 
# Hours from 0 to 24 in 30-minute intervals
hours = np.arange(0, 24.5, 0.5)
print(f"Time points: {len(hours)}")
# Output: Time points: 49
print(hours[:6])
# Output: [0.  0.5 1.  1.5 2.  2.5]

일반적인 오류와 해결 방법

잘못된 스텝 방향으로 인한 빈 배열

np.arange()에서 가장 자주 발생하는 실수는 잘못된 방향의 스텝을 사용하는 것입니다:

import numpy as np
 
# Trying to count down with a positive step
arr = np.arange(10, 0, 1)
print(arr)
# Output: []
 
# Trying to count up with a negative step
arr2 = np.arange(0, 10, -1)
print(arr2)
# Output: []

둘 다 오류나 경고 없이 빈 배열을 반환합니다. 해결책은 간단합니다. 스텝 방향이 start에서 stop으로의 방향과 일치하는지 확인하세요:

import numpy as np
 
# Correct: counting down with negative step
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

0 스텝 크기

0의 스텝은 유효하지 않으며 오류를 발생시킵니다:

import numpy as np
 
try:
    arr = np.arange(0, 10, 0)
except ZeroDivisionError as e:
    print(f"Error: {e}")
# Output: Error: division by zero

예상치 못한 거대한 배열

np.arange()는 전체 배열을 한 번에 메모리에 생성하므로, 큰 범위에 대해 매우 작은 스텝을 사용하면 수 기가바이트의 RAM을 소비할 수 있습니다:

import numpy as np
 
# This creates 10 billion elements -- do NOT run this
# arr = np.arange(0, 10, 0.000000001)
 
# Check the size first
count = int((10 - 0) / 0.000000001)
print(f"This would create {count:,} elements")
# Output: This would create 10,000,000,000 elements
print(f"Memory: ~{count * 8 / 1e9:.1f} GB (for float64)")
# Output: Memory: ~80.0 GB (for float64)

큰 시퀀스를 생성하기 전에 항상 크기를 추정하세요.

RunCell에서 NumPy 실험하기

이 예제들을 대화형으로 시도하고 NumPy를 배우면서 AI 기반 지원을 받고 싶다면, RunCell (opens in a new tab)을 확인해 보세요. RunCell은 Jupyter에 직접 내장된 AI 에이전트로, 데이터 사이언티스트가 코드를 작성, 디버깅, 최적화하는 것을 돕습니다.

문서 탭과 노트북 사이를 전환하는 대신, RunCell에 np.arange() 예제를 생성하거나, 부동소수점 정밀도 동작을 설명하거나, 특정 사용 사례에 대해 arange와 linspace 중 어떤 것을 선택할지 도움을 요청할 수 있습니다. 기존 Jupyter 환경에서 직접 실행되므로 설정의 번거로움이 없습니다. 설치하고 코드 셀 옆에서 바로 질문을 시작하세요.

NumPy 배열 생성 함수를 처음 탐색할 때 특히 유용합니다. 실시간으로 예제를 반복하고 결과를 즉시 확인할 수 있기 때문입니다.

FAQ

numpy arange는 무엇을 반환하나요?

np.arange()는 균등 간격의 값을 포함하는 1차원 NumPy ndarray를 반환합니다. 지연 이터레이터를 반환하는 Python의 range()와 달리, np.arange()는 전체 배열을 메모리에 생성합니다. 배열은 벡터화된 연산, 브로드캐스팅, 모든 표준 NumPy 함수를 지원합니다.

numpy arange에서 부동소수점 스텝 값을 사용할 수 있나요?

네. 정수만 받아들이는 Python의 range()와 달리, np.arange()는 부동소수점 start, stop, step 값을 완전히 지원합니다. 예를 들어, np.arange(0, 1, 0.1)은 [0.0, 0.1, 0.2, ..., 0.9]를 생성합니다. 그러나 부동소수점 반올림으로 인해 결과의 요소 수가 예상보다 하나 많거나 적을 수 있다는 점에 유의하세요. 정확한 요소 수가 필요할 때는 np.linspace()를 사용하세요.

np.arange와 np.linspace의 차이점은 무엇인가요?

np.arange()는 스텝 크기를 받아 stop 값(미포함)에 도달할 때까지 값을 생성합니다. np.linspace()는 원하는 포인트 수를 받아 자동으로 스텝 크기를 계산하며, 기본적으로 끝점을 포함합니다. 스텝 크기를 알고 있을 때는 arange를 사용하세요. 필요한 포인트 수를 알고 있을 때는 linspace를 사용하세요.

np.arange가 빈 배열을 반환하는 이유는 무엇인가요?

스텝 방향이 start에서 stop으로의 방향과 일치하지 않을 때 빈 배열이 반환됩니다. 예를 들어, np.arange(10, 0, 1)은 양수 스텝이 10에서 0으로 이동할 수 없기 때문에 빈 배열을 반환합니다. 해결 방법은 음수 스텝을 사용하는 것입니다: np.arange(10, 0, -1).

np.arange는 stop 값을 포함하나요, 포함하지 않나요?

stop 값은 미포함입니다. 출력에 절대 포함되지 않습니다. np.arange(0, 5)는 [0, 1, 2, 3, 4]를 반환하며, [0, 1, 2, 3, 4, 5]가 아닙니다. 이는 Python 내장 range()의 동작과 일치합니다. 끝점을 포함해야 하는 경우 endpoint=True(기본값)로 np.linspace()를 사용하세요.

결론

np.arange()가 NumPy에서 가장 많이 사용되는 함수 중 하나인 데는 이유가 있습니다: Python에서 균등 간격 숫자의 배열을 생성하는 가장 빠른 방법이기 때문입니다. 기억해야 할 핵심 사항을 요약합니다:

• 인수 하나 (np.arange(n))는 0부터 n-1까지의 정수를 생성합니다.
• 인수 둘 (np.arange(start, stop))은 기본 스텝 1로 범위를 정의합니다.
• 인수 셋 (np.arange(start, stop, step))은 부동소수점 스텝과 내림차순 시퀀스를 위한 음수 스텝을 포함한 완전한 제어를 제공합니다.
• **dtype**은 특정 데이터 타입이 필요할 때 자동 타입 추론을 재정의합니다.
• 스텝 크기가 중요할 때는 **np.arange()**를 사용하세요. 포인트 수가 중요할 때는 **np.linspace()**를 사용하세요.
• 부동소수점 정밀도에 주의하세요 -- 부동소수점 스텝을 사용한 np.arange()는 예상치 못한 수의 요소를 생성할 수 있습니다.
• 빈 배열은 스텝 방향과 start에서 stop으로의 방향 불일치에서 발생합니다.

NumPy 배열로 대화형 실험을 하려면, RunCell (opens in a new tab)이 Jupyter에서 직접 AI 지원 코딩을 제공하여, 노트북을 떠나지 않고도 np.arange() 변형을 테스트하고 즉각적인 설명을 받을 수 있습니다.