How to Create an Array from 1 to N in Python

Last Modified Date: by

I recently built a small leave request tool for a 10-person U.S. team. HR tracked paid time off in Excel, but duplicate employee IDs made reports difficult to maintain. I needed to create an array from 1 to N in Python so every employee received a predictable numeric ID.

The tool ran locally, stored requests in a SQLite database, and used a simple command-line interface. A sequence such as [1, 2, 3, ..., N] helped me generate employee IDs, test records, and approval queues.

You will learn several practical approaches, when to use each one, and how to handle real user input safely.

What Does an Array from 1 to N Mean in Python?

An array from 1 to N contains consecutive integers starting at 1 and ending at N. If N equals 5, the expected result looks like this:

[1, 2, 3, 4, 5]

The ending value matters because Python often treats the upper boundary as exclusive. For example, range(1, 5) produces numbers from 1 through 4. You must use N + 1 when you want to include N.

Python developers often use the word array loosely. Depending on the project, it may refer to one of these structures:

  • A built-in list, which stores multiple values and works well in most scripts.
  • A range object, which represents a numeric sequence without storing every number immediately.
  • An array.array object, which stores values of one data type.
  • A NumPy array, which supports fast numeric calculations.

If you are new to these structures, review how to create arrays in Python before choosing one.

For a small command-line application, I normally use a list. It requires no package installation, prints clearly, and supports familiar operations such as indexing and appending.

Best Way to Create an Array from 1 to N in Python

The simplest approach uses the built-in range() function with list():

n = 10
numbers = list(range(1, n + 1))

print(numbers)

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

You can see the output in the screenshot below.

Create an Array from 1 to N in Python

The range() call receives two boundaries. The first argument, 1, tells Python where to start. The second argument, n + 1, stops the sequence immediately after N.

The list() function then converts that sequence into a standard Python list. This conversion lets you print, modify, slice, or pass the values to another function.

I recommend this approach for most beginner Python projects because it stays readable. Another developer can understand the intention without studying a loop.

You can confirm that the result contains N elements with len():

n = 10
numbers = list(range(1, n + 1))

print(numbers)
print("Number of elements:", len(numbers))

Output:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Number of elements: 10

The first element sits at index 0, while the last element sits at index n - 1. Python uses zero-based indexing even though the stored values begin at 1.

print("First value:", numbers[0])
print("Last value:", numbers[-1])

Output:

First value: 1
Last value: 10

You can learn more about sequence processing in this guide to looping through a Python list.

Pro Tip: I’ve found that range(1, n) causes more mistakes than any other line in this task. Add 1 to the stopping value whenever the final number must appear in the result.

Create an Array from 1 to N Without Converting range()

You do not always need a list. The range object works better when your code only needs to loop through numbers.

n = 5
numbers = range(1, n + 1)

print(numbers)

for number in numbers:
    print(number, end=" ")

Output:

range(1, 6)
1 2 3 4 5

You can see the output in the screenshot below.

How to Create an Array from 1 to N in Python

A range stores its start, stop, and step settings instead of creating every integer immediately. This behavior saves memory when N becomes large.

For example, this range represents one million numbers:

numbers = range(1, 1_000_001)

print(numbers[0])
print(numbers[-1])
print(len(numbers))

Output:

1
1000000
1000000

Use a range when you need iteration, indexing, or membership testing but do not need a physical list. Convert it to a list only when another part of your program requires one.

For example, checking whether employee ID 275 exists remains straightforward:

employee_ids = range(1, 501)

print(275 in employee_ids)
print(700 in employee_ids)

Output:

True
False

This approach works well for validation rules, numbered menus, report rows, and batch-processing loops.

Create the Sequence with a for Loop

A traditional for loop gives you more control over how each value enters the array. It takes more code than list(range()), but it helps when each number needs validation or transformation.

n = 5
numbers = []

for number in range(1, n + 1):
    numbers.append(number)

print(numbers)

Output:

[1, 2, 3, 4, 5]

You can see the output in the screenshot below.

Create an Python Array from 1 to N

The code starts with an empty list. Each loop cycle adds one number through the append() method.

This approach is useful when you want only values that meet a condition. Suppose HR needs employee IDs for two-person approval batches and wants only even-numbered IDs:

n = 10
even_employee_ids = []

for employee_id in range(1, n + 1):
    if employee_id % 2 == 0:
        even_employee_ids.append(employee_id)

print(even_employee_ids)

Output:

[2, 4, 6, 8, 10]

The modulo operator % returns the remainder from division. An even number produces a remainder of zero when divided by two.

You can review related techniques for adding elements to a Python list with a for loop.

Use a List Comprehension for Customized Values

A list comprehension creates a list using a compact loop expression. It works well when you need consecutive values plus a simple transformation.

n = 5
numbers = [number for number in range(1, n + 1)]

print(numbers)

Output:

[1, 2, 3, 4, 5]

This version produces the same result as list(range()), so it adds no real benefit by itself. Its value appears when you change each number.

For example, you can create U.S. employee labels:

n = 5
employee_codes = [f"US-EMP-{number:03d}" for number in range(1, n + 1)]

print(employee_codes)

Output:

['US-EMP-001', 'US-EMP-002', 'US-EMP-003', 'US-EMP-004', 'US-EMP-005']

The expression {number:03d} formats each integer with three digits. Python adds leading zeros when necessary.

You can also create odd-numbered values:

n = 10
odd_numbers = [
    number
    for number in range(1, n + 1)
    if number % 2 != 0
]

print(odd_numbers)

Output:

[1, 3, 5, 7, 9]

Use a list comprehension for short, readable transformations. Choose a regular loop when the logic requires several conditions or error checks.

How to Create an Array from 1 to N in Python with NumPy

NumPy is a third-party package built for numerical computing. Its arange() function creates a numeric array from a starting value, stopping value, and optional step.

Install NumPy from your terminal if your environment does not already include it:

python -m pip install numpy

Then create the array:

import numpy as np

n = 10
numbers = np.arange(1, n + 1)

print(numbers)
print(type(numbers))

Output:

[ 1  2  3  4  5  6  7  8  9 10]
<class 'numpy.ndarray'>

Like range(), np.arange() excludes its stopping value. Using n + 1 includes N.

A NumPy array becomes valuable when you perform calculations across every element. Suppose each number represents available paid-time-off hours, and HR wants to double them for a test dataset:

import numpy as np

n = 5
hours = np.arange(1, n + 1)
doubled_hours = hours * 2

print("Original:", hours)
print("Doubled:", doubled_hours)

Output:

Original: [1 2 3 4 5]
Doubled: [ 2  4  6  8 10]

NumPy performs this operation without an explicit Python loop. This technique, called vectorization, applies an operation across an entire array.

Use NumPy for data science, statistics, matrices, or large numerical workloads. A basic automation script does not need this dependency. Explore the wider feature set in this Python NumPy array guide and the detailed explanation of the arange function in Python.

Create a Typed Array with the array Module

Python includes the array module in its standard library. Unlike a list, a typed array restricts all elements to one data type.

from array import array

n = 5
numbers = array("i", range(1, n + 1))

print(numbers)
print(numbers.tolist())

Output:

array('i', [1, 2, 3, 4, 5])
[1, 2, 3, 4, 5]

The type code "i" means signed integer. The tolist() method converts the typed array into a normal list.

Use array.array when you need compact storage for many values but do not need NumPy calculations. Most business scripts remain easier to maintain with standard lists.

If another function already gives you a list, follow these steps to convert a list to an array in Python.

Accept N from User Input

A practical command-line application usually receives N from the user. The built-in input() function always returns text, so you must convert the value to an integer.

n = int(input("Enter the number of U.S. employees: "))
employee_ids = list(range(1, n + 1))

print("Employee IDs:", employee_ids)

Example input:

Enter the number of U.S. employees: 6

Output:

Employee IDs: [1, 2, 3, 4, 5, 6]

The int() function converts the entered string into an integer. If someone enters six, Python raises a ValueError.

Handle that problem with try and except:

try:
    n = int(input("Enter the number of U.S. employees: "))

    if n < 1:
        print("Enter a whole number greater than zero.")
    else:
        employee_ids = list(range(1, n + 1))
        print("Employee IDs:", employee_ids)

except ValueError:
    print("Enter a valid whole number, such as 10.")

Example input and output:

Enter the number of U.S. employees: ten
Enter a valid whole number, such as 10.

This validation prevents the application from crashing. See how to use the input function in Python and convert a string to an integer for more input patterns.

Use the Array in a Small Leave Request App

My leave request tool used employee IDs from 1 through N. It ran on a local machine with Python 3.11 and stored requests in a SQLite database. SQLite stores structured data inside one local file and requires no database server.

For a small team, I kept the project simple:

leave_app/
├── app.py
└── leave_requests.db

The following setup creates a table for U.S. paid-time-off requests:

import sqlite3

connection = sqlite3.connect("leave_requests.db")

connection.execute("""
CREATE TABLE IF NOT EXISTS leave_requests (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    employee_id INTEGER NOT NULL,
    start_date TEXT NOT NULL,
    end_date TEXT NOT NULL,
    duration_days INTEGER NOT NULL,
    status TEXT NOT NULL DEFAULT 'Pending'
)
""")

connection.commit()
print("Leave request table is ready.")

Output:

Leave request table is ready.

A table organizes related database records into rows and columns. The CREATE TABLE statement runs only when the table does not already exist.

Next, generate valid IDs and add a request:

from datetime import datetime

employee_count = 10
valid_employee_ids = list(range(1, employee_count + 1))

employee_id = 4
start_text = "2026-07-27"
end_text = "2026-07-31"

if employee_id not in valid_employee_ids:
    print("Invalid employee ID.")
else:
    start_date = datetime.strptime(start_text, "%Y-%m-%d")
    end_date = datetime.strptime(end_text, "%Y-%m-%d")
    duration = (end_date - start_date).days + 1

    connection.execute(
        """
        INSERT INTO leave_requests
        (employee_id, start_date, end_date, duration_days)
        VALUES (?, ?, ?, ?)
        """,
        (employee_id, start_text, end_text, duration),
    )
    connection.commit()

    print(f"Request saved for employee {employee_id}.")
    print(f"Calendar duration: {duration} days.")

Output:

Request saved for employee 4.
Calendar duration: 5 days.

The datetime module converts date text into date-aware objects. Subtracting the start date from the end date calculates the duration. Adding one includes both requested dates.

A p