How to Create an Array from 1 to N in Python

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.

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.

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.

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 production HR system should calculate business days and exclude U.S. federal holidays. This smaller example uses calendar days to keep the array logic clear.

You can list the requests and approve one with two small functions. A function groups reusable instructions under a descriptive name.

def list_requests(connection):
    rows = connection.execute(
        """
        SELECT id, employee_id, start_date, end_date, status
        FROM leave_requests
        ORDER BY id
        """
    ).fetchall()

    for row in rows:
        print(row)


def approve_request(connection, request_id):
    connection.execute(
        """
        UPDATE leave_requests
        SET status = 'Approved'
        WHERE id = ?
        """,
        (request_id,),
    )
    connection.commit()
    print(f"Request {request_id} approved.")


list_requests(connection)
approve_request(connection, 1)

Output:

(1, 4, '2026-07-27', '2026-07-31', 'Pending')
Request 1 approved.

These functions cover the read and update parts of CRUD operations. CRUD means create, read, update, and delete, the four common actions used in data applications.

A command-line application works well for internal testing. You could later add a Tkinter GUI, which means a graphical user interface with windows, buttons, and input fields.

Things to Keep in Mind

• Remember the exclusive stopping value: Use range(1, n + 1) or np.arange(1, n + 1) when the array must include N.
• Validate user input: Reject text, decimals, zero, and negative values before creating the sequence. Large accidental inputs may consume significant memory when converted into a list.
• Use range for large sequences: Keep the range object when you only need iteration. Creating a list of millions of integers adds unnecessary memory usage.
• Choose the correct structure: Use a list for general scripting, NumPy for numeric calculations, and array.array for typed storage.
• Avoid hard-coded limits: Read employee counts from configuration or the database when the real application changes frequently.
• Protect application data: Back up the SQLite file, use parameterized queries, and restrict who can approve leave requests.

Frequently Asked Questions

You learned how to build sequences from 1 through N using lists, ranges, loops, NumPy, and typed arrays. For most local scripts, list(range(1, n + 1)) offers the clearest and most practical solution. I hope you found this article helpful.

You May Also Like

• How to initialize an array in Python
• How to print an array in Python
• How to check the length of an array in Python
• How to reverse an array in Python
• How to initialize a list of size N in Python

Bijay Kumar

Bijay Kumar is an experienced Python and AI professional who enjoys helping developers learn modern technologies through practical tutorials and examples. His expertise includes Python development, Machine Learning, Artificial Intelligence, automation, and data analysis using libraries like Pandas, NumPy, TensorFlow, Matplotlib, SciPy, and Scikit-Learn. At PythonGuides.com, he shares in-depth guides designed for both beginners and experienced developers. More about us.

enjoysharepoint.com/