I often start small automation scripts with a simple list. For example, when I build a local command-line app to track leave requests for a 10-person team, I need a place to collect employee names, requested dates, and approval statuses before saving anything.
That is where knowing how to append to an array in Python becomes useful. Python developers usually use lists as flexible arrays, but you may also work with the built-in array module or a NumPy array in data-heavy projects.
In this guide, I will show you the practical ways to append values, multiple items, records, and NumPy data without creating common bugs.
What Does Append to Array Mean in Python?
An array is an ordered collection of values. In Python, a list is the most common structure people call an array because it stores multiple values in one variable and lets you change it later.
For example, this list stores leave types for a small HR leave management script:
leave_types = ["Sick Leave", "Casual Leave", "Earned Leave"]
print(leave_types)
Output:
['Sick Leave', 'Casual Leave', 'Earned Leave']
I executed the above example code and added the screenshot below.
When you append something, you add it to the end of that collection. You can append a single employee name, a complete leave request record, or values received from user input.
If you are new to Python collections, it also helps to understand the difference between lists, tuples, sets, and dictionaries. Each structure solves a different problem, but lists work best when the order of items matters and you expect changes.
Append to Array in Python With append()
The append() method is the best option when you need to add one item to the end of a Python list. It changes the original list directly.
Here is a basic example:
employees = ["Emily", "Michael", "Sophia"]
employees.append("James")
print(employees)
Output:
['Emily', 'Michael', 'Sophia', 'James']
I executed the above example code and added the screenshot below.
The append() method adds "James" as one new item at the final position. It does not create a new list.
This is useful in a command-line application where users enter one leave request at a time.
leave_requests = []
employee_name = input("Enter employee name: ")
leave_requests.append(employee_name)
print("Current requests:", leave_requests)
If the user enters Emily, Python stores that value in the list:
Current requests: ['Emily']
Use append() when your script receives one value per action. It keeps the code easy to read and works well for beginner Python projects.
You can also explore how to add elements to an empty list in Python when you need more examples with blank lists.
Pro Tip: I have found that
append()is the safest choice for collecting one record at a time. Do not assign its result to another variable becauseappend()returnsNone, not the updated list.
For example, this is incorrect:
employees = ["Emily", "Michael"]
updated_employees = employees.append("Sophia")
print(updated_employees)
Output:
None
I executed the above example code and added the screenshot below.
Write this instead:
employees = ["Emily", "Michael"]
employees.append("Sophia")
print(employees)
Append Multiple Values With extend()
Use extend() when you need to append several values from another iterable. An iterable is an object that Python can loop through, such as a list, tuple, string, or set.
Suppose your leave management script receives a batch of employees from another department:
employees = ["Emily", "Michael"]
new_employees = ["Sophia", "James", "Olivia"]
employees.extend(new_employees)
print(employees)
Output:
['Emily', 'Michael', 'Sophia', 'James', 'Olivia']
The extend() method adds each employee as a separate list item. This differs from append().
employees = ["Emily", "Michael"]
new_employees = ["Sophia", "James"]
employees.append(new_employees)
print(employees)
Output:
['Emily', 'Michael', ['Sophia', 'James']]
Python adds the complete new_employees list as one nested item. That may be correct when you want grouped data, but it is wrong when you expect a flat employee list.
Here is the difference:
| Method | Input | Result |
|---|---|---|
| append() | One item | Adds one item, including a list as a nested list |
| extend() | Multiple values | Adds each value as a separate item |
For batch data, extend() creates cleaner results. You can later flatten a list of lists in Python if nested data already exists.
Append a List to Create Nested Data
Sometimes you actually want a nested list. A nested list is a list that contains one or more lists.
For a leave request app, each leave request might contain an employee name, start date, end date, and approval status.
leave_requests = []
request = ["Emily", "2026-07-20", "2026-07-22", "Pending"]
leave_requests.append(request)
print(leave_requests)
Output:
[['Emily', '2026-07-20', '2026-07-22', 'Pending']]
This approach keeps each leave request together. You can add another request later:
leave_requests.append(
["Michael", "2026-07-25", "2026-07-25", "Approved"]
)
print(leave_requests)
Output:
[
['Emily', '2026-07-20', '2026-07-22', 'Pending'],
['Michael', '2026-07-25', '2026-07-25', 'Approved']
]
You can access the first request with an index:
first_request = leave_requests[0]
print(first_request)
print(first_request[0])
Output:
['Emily', '2026-07-20', '2026-07-22', 'Pending']
Emily
The first index selects the request, and the second index selects a value inside that request. If you work with this layout, learn how to iterate through a 2D array in Python because nested lists behave like a simple two-dimensional array.
Build a Leave Request List Step by Step
Let us build a small real-world example. This local Python script collects leave requests from employees and appends each record to a list.
Create a file named leave_requests.py:
leave-request-app/
│
└── leave_requests.py
This one-file structure works well for a small practice project. Once your app grows, move functions into separate modules for input validation, database work, and reporting.
Start with an empty list:
leave_requests = []
Next, collect values from the user:
employee_name = input("Enter employee name: ")
start_date = input("Enter start date (YYYY-MM-DD): ")
end_date = input("Enter end date (YYYY-MM-DD): ")
leave_type = input("Enter leave type: ")
Now combine those values into one record:
request = {
"employee": employee_name,
"start_date": start_date,
"end_date": end_date,
"leave_type": leave_type,
"status": "Pending"
}
A dictionary stores data as key-value pairs. It makes the record easier to understand than a list because you access values by names like "employee" and "status".
Append the dictionary to the main list:
leave_requests.append(request)
print("\nLeave request added successfully.")
print(leave_requests)
Here is the complete script:
leave_requests = []
employee_name = input("Enter employee name: ")
start_date = input("Enter start date (YYYY-MM-DD): ")
end_date = input("Enter end date (YYYY-MM-DD): ")
leave_type = input("Enter leave type: ")
request = {
"employee": employee_name,
"start_date": start_date,
"end_date": end_date,
"leave_type": leave_type,
"status": "Pending"
}
leave_requests.append(request)
print("\nLeave request added successfully.")
print(leave_requests)
A sample run looks like this:
Enter employee name: Emily
Enter start date (YYYY-MM-DD): 2026-07-20
Enter end date (YYYY-MM-DD): 2026-07-22
Enter leave type: Casual Leave
Leave request added successfully.
[{'employee': 'Emily', 'start_date': '2026-07-20',
'end_date': '2026-07-22', 'leave_type': 'Casual Leave',
'status': 'Pending'}]
For a growing script, put the append logic inside a reusable function:
def add_leave_request(requests, employee, start_date, end_date, leave_type):
request = {
"employee": employee,
"start_date": start_date,
"end_date": end_date,
"leave_type": leave_type,
"status": "Pending"
}
requests.append(request)
Call the function like this:
leave_requests = []
add_leave_request(
leave_requests,
"Emily",
"2026-07-20",
"2026-07-22",
"Casual Leave"
)
print(leave_requests)
A function groups reusable code under a meaningful name. It helps you avoid repeating the same dictionary and append logic throughout your application. For more practice, see how to define a function in Python.
Validate Data Before You Append
Do not append user input immediately in a real script. Validate it first. Validation checks whether a value meets your rules before your application stores it.
Dates create many avoidable problems. Users may enter 20/07/2026, July 20, or an impossible date such as 2026-02-30. Use the datetime module to confirm the format and calculate leave duration.
from datetime import datetime
def get_valid_date(prompt):
while True:
date_text = input(prompt)
try:
return datetime.strptime(date_text, "%Y-%m-%d").date()
except ValueError:
print("Enter a valid date in YYYY-MM-DD format.")
The datetime.strptime() function converts text into a date object. The try block runs code that may fail, while the except block handles the error without ending the app.
Now use it in the leave request workflow:
from datetime import datetime
leave_requests = []
def get_valid_date(prompt):
while True:
date_text = input(prompt)
try:
return datetime.strptime(date_text, "%Y-%m-%d").date()
except ValueError:
print("Enter a valid date in YYYY-MM-DD format.")
employee_name = input("Enter employee name: ").strip()
start_date = get_valid_date("Enter start date (YYYY-MM-DD): ")
end_date = get_valid_date("Enter end date (YYYY-MM-DD): ")
if end_date < start_date:
print("End date cannot be earlier than start date.")
else:
duration = (end_date - start_date).days + 1
request = {
"employee": employee_name,
"start_date": start_date.isoformat(),
"end_date": end_date.isoformat(),
"days": duration,
"status": "Pending"
}
leave_requests.append(request)
print(f"Request added for {duration} day(s).")
The .strip() method removes accidental spaces from the beginning and end of the employee name. The .isoformat() method converts the date back to the consistent YYYY-MM-DD text format.
You can also read more about how to check if a string is a valid date in Python before building date-based scripts.
Pro Tip: In my experience, always validate values before calling
append(). Removing invalid records later gets difficult when your list feeds reports, files, or a SQLite database.
Append to a Python Array Module
Python also includes an array module. Unlike a list, an array stores values of one data type, such as integers or decimal numbers.
Use it when you need a compact sequence of numeric values and do not need mixed data types.
from array import array
leave_days = array("i", [2, 1, 3])
leave_days.append(5)
print(leave_days)
Output:
array('i', [2, 1, 3, 5])
The "i" type code means signed integer values. You cannot append a string to this numeric array.
from array import array
leave_days = array("i", [2, 1, 3])
leave_days.append("five")
Python raises an error because "five" is text, not an integer.
For most business automation scripts, I recommend using lists. Lists are more flexible and easier to work with when you need names, dates, statuses, and other mixed values. Use the array module only when your requirements clearly call for one numeric data type.
Append to a NumPy Array
Use NumPy when you work with large numeric datasets, matrices, scientific calculations, or data analysis. A NumPy array supports fast mathematical operations, but it handles appending differently from Python lists.
First, install NumPy if your project does not have it: