how to make assignment index

• PRO Courses Guides New Tech Help Pro Expert Videos About wikiHow Pro Upgrade Sign In
• EDIT Edit this Article
• EXPLORE Tech Help Pro About Us Random Article Quizzes Request a New Article Community Dashboard This Or That Game Happiness Hub Popular Categories Arts and Entertainment Artwork Books Movies Computers and Electronics Computers Phone Skills Technology Hacks Health Men's Health Mental Health Women's Health Relationships Dating Love Relationship Issues Hobbies and Crafts Crafts Drawing Games Education & Communication Communication Skills Personal Development Studying Personal Care and Style Fashion Hair Care Personal Hygiene Youth Personal Care School Stuff Dating All Categories Arts and Entertainment Finance and Business Home and Garden Relationship Quizzes Cars & Other Vehicles Food and Entertaining Personal Care and Style Sports and Fitness Computers and Electronics Health Pets and Animals Travel Education & Communication Hobbies and Crafts Philosophy and Religion Work World Family Life Holidays and Traditions Relationships Youth
• Browse Articles
• Learn Something New
• Quizzes Hot
• Happiness Hub
• This Or That Game
• Train Your Brain
• Explore More
• Support wikiHow
• About wikiHow
• Log in / Sign up
• Education and Communications
• Technical Writing

How to Write an Index

Last Updated: January 25, 2024 Fact Checked

This article was co-authored by Christopher Taylor, PhD and by wikiHow staff writer, Jennifer Mueller, JD . Christopher Taylor is an Adjunct Assistant Professor of English at Austin Community College in Texas. He received his PhD in English Literature and Medieval Studies from the University of Texas at Austin in 2014. This article has been fact-checked, ensuring the accuracy of any cited facts and confirming the authority of its sources. This article has been viewed 2,007,024 times.

An index is an alphabetical list of keywords contained in the text of a book or other lengthy writing project. It includes pointers to where those keywords or concepts are mentioned in the book—typically page numbers, but sometimes footnote numbers, chapters, or sections. The index can be found at the end of the work, and makes a longer nonfiction work more accessible for readers, since they can turn directly to the information they need. Typically you'll start indexing after you've completed the main writing and research. [1] X Research source

Preparing Your Index

• Typically, if you index from a hard copy you'll have to transfer your work to a digital file. If the work is particularly long, try to work straight from the computer so you can skip this extra step.

• If footnotes or endnotes are merely source citations, they don't need to be included in the index.
• Generally, you don't need to index glossaries, bibliographies, acknowledgements, or illustrative items such as charts and graphs.
• If you're not sure whether something should be indexed, ask yourself if it contributes something substantial to the text. If it doesn't, it typically doesn't need to be indexed.

• In most cases, if you have a "works cited" section appearing at the end of your text you won't need to index authors. You would still include their names in the general index, however, if you discussed them in the text rather than simply citing their work.

• For example, if you're writing a book on bicycle maintenance, you might have index cards for "gears," "wheels," and "chain."
• Put yourself in your reader's shoes, and ask yourself why they would pick up your book and what information they would likely be looking for. Chapter or section headings can help guide you as well.

• For example, a dessert cookbook that included several types of ice cream might have one entry for "ice cream," followed by subentries for "strawberry," "chocolate," and "vanilla."
• Treat proper nouns as a single unit. For example, "United States Senate" and "United States House of Representatives" would be separate entries, rather than subentries under the entry "United States."

• Stick to nouns and brief phrases for subentries, avoiding any unnecessary words.
• For example, suppose you are writing a book about comic books that discusses Wonder Woman's influence on the feminist movement. You might include a subentry under "Wonder Woman" that says "influence on feminism."

• For example, if you were writing a dessert cookbook, you might have entries for "ice cream" and "sorbet." Since these frozen treats are similar, they would make good cross references of each other.

Formatting Entries and Subentries

• The style guide provides specifics for you in terms of spacing, alignment, and punctuation of your entries and subentries.

• For example, an entry in the index of a political science book might read: "capitalism: 21st century, 164; American free trade, 112; backlash against, 654; expansion of, 42; Russia, 7; and television, 3; treaties, 87."
• If an entry contains no subentries, simply follow the entry with a comma and list the page numbers.

• People's names typically are listed alphabetically by their last name. Put a comma after the last name and add the person's first name.
• Noun phrases typically are inverted. For example, "adjusting-height saddle" would be listed in an index as "saddle, adjusting-height." [8] X Research source

• Avoid repeating words in the entry in the subentries. If several subentries repeat the same word, add it as a separate entry, with a cross reference back to the original entry. For example, in a dessert cookbook you might have entries for "ice cream, flavors" and "ice cream, toppings."
• Subentries typically are listed alphabetically as well. If subentry terms have symbols, hyphens, slashes, or numbers, you can usually ignore them.

• If a proper name, such as the name of a book or song, includes a word such as "a" or "the" at the beginning of the title, you can either omit it or include it after a comma ("Importance of Being Earnest, The"). Check your style guide for the proper rule that applies to your index, and be consistent.

• When listing a series of pages, if the first page number is 1-99 or a multiple of 100, you also use all of the digits. For example, "ice cream: vanilla, 100-109."
• For other numbers, you generally only have to list the digits that changed for subsequent page numbers. For example, "ice cream: vanilla, 112-18."
• Use the word passim if references are scattered over a range of pages. For example, "ice cream: vanilla, 45-68 passim . Only use this if there are a large number of references within that range of pages.

• Place a period after the last page number in the entry, then type See also in italics, with the word "see" capitalized. Then include the name of the similar entry you want to use.
• For example, an entry in an index for a dessert cookbook might contain the following entry: "ice cream: chocolate, 4, 17, 24; strawberry, 9, 37; vanilla, 18, 25, 32-35. See also sorbet."

• For example, a beginning cyclist may be looking in a manual for "tire patches," which are called "boots" in cycling terms. If you're writing a bicycle manual aimed at beginners, you might include a "see" cross reference: "tire patches, see boots."

Editing Your Index

• You'll also want to search for related terms, especially if you talk about a general concept in the text without necessarily mentioning it by name.

• If you have any entries that are too complex or that might confuse your readers, you might want to simplify them or add a cross reference.
• For example, a bicycle maintenance text might discuss "derailleurs," but a novice would more likely look for terms such as "gearshift" or "shifter" and might not recognize that term.

• For example, you might include an entry in a dessert cookbook index that read "ice cream, varieties of: chocolate, 54; strawberry, 55; vanilla, 32, 37, 56. See also sorbet."

• Generally, an entry should occur on two or three page numbers. If it's only found in one place, you may not need to include it at all. If you decide it is necessary, see if you can include it as a subentry under a different entry.
• For example, suppose you are indexing a dessert cookbook, and it has ice cream on two pages and sorbet on one page. You might consider putting these together under a larger heading, such as "frozen treats."

• You may want to run searches again to make sure the index is comprehensive and includes as many pointers as possible to help guide your readers.

• Make sure any cross references match the exact wording of the entry or entries they reference.

• Indexes are typically set in 2 columns, using a smaller font than that used in the main text. Entries begin on the first space of the line, with the subsequent lines of the same entry indented.

Expert Q&A

• If creating an index seems like too large of a task for you to complete on your own by the publisher's deadline, you may be able to hire a professional indexer to do the work for you. Look for someone who has some knowledge and understanding about the subject matter of your work. Thanks Helpful 0 Not Helpful 0
• Make the index as clear and simple as you can. Readers don't like looking through a messy, hard-to-read index. Thanks Helpful 0 Not Helpful 0

• If you're using a word processing app that has an indexing function, avoid relying on it too much. It will index all of the words in your text, which will be less than helpful to readers. [15] X Research source Thanks Helpful 0 Not Helpful 0

You Might Also Like

• ↑ https://ugapress.org/resources/for-authors/indexing-guidelines/
• ↑ https://www.hup.harvard.edu/resources/authors/pdf/hup-author-guidelines-indexing.pdf
• ↑ https://www.press.uchicago.edu/Misc/Chicago/CHIIndexingComplete.pdf
• ↑ https://edinburghuniversitypress.com/publish-with-us/from-manuscript-to-finished-book/preparing-your-index

About This Article

An index is an alphabetical list of keywords found in a book or other lengthy writing project. It will have the chapters or page numbers where readers can find that keyword and more information about it. Typically, you’ll write your index after you’ve completed the main writing and research. In general, you’ll want to index items that are nouns, like ideas, concepts, and things, that add to the subject of the text. For example, a dessert cookbook might have an entry for “ice cream” followed by subentries for “strawberry,” “chocolate,” and “vanilla.” To learn how to format your index entries, keep reading! Did this summary help you? Yes No

• Send fan mail to authors

Reader Success Stories

Lisa Nielsen

May 30, 2017

Did this article help you?

Oct 25, 2016

Caroline Mckillop

Oct 16, 2019

Maureen Leonard

Jul 5, 2016

Graham Lidiard

Aug 3, 2016

Featured Articles

Trending Articles

Watch Articles

• Terms of Use
• Privacy Policy
• Do Not Sell or Share My Info
• Not Selling Info

Don’t miss out! Sign up for

wikiHow’s newsletter

Nick McCullum

Software Developer & Professional Explainer

NumPy Indexing and Assignment

Hey - Nick here! This page is a free excerpt from my $199 course Python for Finance, which is 50% off for the next 50 students.

If you want the full course, click here to sign up.

In this lesson, we will explore indexing and assignment in NumPy arrays.

The Array I'll Be Using In This Lesson

As before, I will be using a specific array through this lesson. This time it will be generated using the np.random.rand method. Here's how I generated the array:

Here is the actual array:

To make this array easier to look at, I will round every element of the array to 2 decimal places using NumPy's round method:

Here's the new array:

How To Return A Specific Element From A NumPy Array

We can select (and return) a specific element from a NumPy array in the same way that we could using a normal Python list: using square brackets.

An example is below:

We can also reference multiple elements of a NumPy array using the colon operator. For example, the index [2:] selects every element from index 2 onwards. The index [:3] selects every element up to and excluding index 3. The index [2:4] returns every element from index 2 to index 4, excluding index 4. The higher endpoint is always excluded.

A few example of indexing using the colon operator are below.

Element Assignment in NumPy Arrays

We can assign new values to an element of a NumPy array using the = operator, just like regular python lists. A few examples are below (note that this is all one code block, which means that the element assignments are carried forward from step to step).

arr[2:5] = 0.5

Returns array([0. , 0. , 0.5, 0.5, 0.5])

As you can see, modifying second_new_array also changed the value of new_array .

Why is this?

By default, NumPy does not create a copy of an array when you reference the original array variable using the = assignment operator. Instead, it simply points the new variable to the old variable, which allows the second variable to make modification to the original variable - even if this is not your intention.

This may seem bizarre, but it does have a logical explanation. The purpose of array referencing is to conserve computing power. When working with large data sets, you would quickly run out of RAM if you created a new array every time you wanted to work with a slice of the array.

Fortunately, there is a workaround to array referencing. You can use the copy method to explicitly copy a NumPy array.

An example of this is below.

As you can see below, making modifications to the copied array does not alter the original.

So far in the lesson, we have only explored how to reference one-dimensional NumPy arrays. We will now explore the indexing of two-dimensional arrays.

Indexing Two-Dimensional NumPy Arrays

To start, let's create a two-dimensional NumPy array named mat :

There are two ways to index a two-dimensional NumPy array:

• mat[row, col]
• mat[row][col]

I personally prefer to index using the mat[row][col] nomenclature because it is easier to visualize in a step-by-step fashion. For example:

You can also generate sub-matrices from a two-dimensional NumPy array using this notation:

Array referencing also applies to two-dimensional arrays in NumPy, so be sure to use the copy method if you want to avoid inadvertently modifying an original array after saving a slice of it into a new variable name.

Conditional Selection Using NumPy Arrays

NumPy arrays support a feature called conditional selection , which allows you to generate a new array of boolean values that state whether each element within the array satisfies a particular if statement.

An example of this is below (I also re-created our original arr variable since its been awhile since we've seen it):

You can also generate a new array of values that satisfy this condition by passing the condition into the square brackets (just like we do for indexing).

An example of this is below:

Conditional selection can become significantly more complex than this. We will explore more examples in this section's associated practice problems.

In this lesson, we explored NumPy array indexing and assignment in thorough detail. We will solidify your knowledge of these concepts further by working through a batch of practice problems in the next section.

IndexError: list assignment index out of range in Python

Last updated: Apr 8, 2024 Reading time · 9 min

# Table of Contents

• IndexError: list assignment index out of range
• (CSV) IndexError: list index out of range
• sys.argv[1] IndexError: list index out of range
• IndexError: pop index out of range

Make sure to click on the correct subheading depending on your error message.

# IndexError: list assignment index out of range in Python

The Python "IndexError: list assignment index out of range" occurs when we try to assign a value at an index that doesn't exist in the list.

To solve the error, use the append() method to add an item to the end of the list, e.g. my_list.append('b') .

Here is an example of how the error occurs.

The list has a length of 3 . Since indexes in Python are zero-based, the first index in the list is 0 , and the last is 2 .

Trying to assign a value to any positive index outside the range of 0-2 would cause the IndexError .

# Adding an item to the end of the list with append()

If you need to add an item to the end of a list, use the list.append() method instead.

The list.append() method adds an item to the end of the list.

The method returns None as it mutates the original list.

# Changing the value of the element at the last index in the list

If you meant to change the value of the last index in the list, use -1 .

When the index starts with a minus, we start counting backward from the end of the list.

# Declaring a list that contains N elements and updating a certain index

Alternatively, you can declare a list that contains N elements with None values.

The item you specify in the list will be contained N times in the new list the operation returns.

Make sure to wrap the value you want to repeat in a list.

If the list contains a value at the specific index, then you are able to change it.

# Using a try/except statement to handle the error

If you need to handle the error if the specified list index doesn't exist, use a try/except statement.

The list in the example has 3 elements, so its last element has an index of 2 .

We wrapped the assignment in a try/except block, so the IndexError is handled by the except block.

You can also use a pass statement in the except block if you need to ignore the error.

The pass statement does nothing and is used when a statement is required syntactically but the program requires no action.

# Getting the length of a list

If you need to get the length of the list, use the len() function.

The len() function returns the length (the number of items) of an object.

The argument the function takes may be a sequence (a string, tuple, list, range or bytes) or a collection (a dictionary, set, or frozen set).

If you need to check if an index exists before assigning a value, use an if statement.

This means that you can check if the list's length is greater than the index you are trying to assign to.

# Trying to assign a value to an empty list at a specific index

Note that if you try to assign to an empty list at a specific index, you'd always get an IndexError .

You should print the list you are trying to access and its length to make sure the variable stores what you expect.

# Use the extend() method to add multiple items to the end of a list

If you need to add multiple items to the end of a list, use the extend() method.

The list.extend method takes an iterable (such as a list) and extends the list by appending all of the items from the iterable.

The list.extend method returns None as it mutates the original list.

# (CSV) IndexError: list index out of range in Python

The Python CSV "IndexError: list index out of range" occurs when we try to access a list at an index out of range, e.g. an empty row in a CSV file.

To solve the error, check if the row isn't empty before accessing it at an index, or check if the index exists in the list.

Assume we have the following CSV file.

And we are trying to read it as follows.

# Check if the list contains elements before accessing it

One way to solve the error is to check if the list contains any elements before accessing it at an index.

The if statement checks if the list is truthy on each iteration.

All values that are not truthy are considered falsy. The falsy values in Python are:

• constants defined to be falsy: None and False .
• 0 (zero) of any numeric type
• empty sequences and collections: "" (empty string), () (empty tuple), [] (empty list), {} (empty dictionary), set() (empty set), range(0) (empty range).

# Check if the index you are trying to access exists in the list

Alternatively, you can check whether the specific index you are trying to access exists in the list.

This means that you can check if the list's length is greater than the index you are trying to access.

# Use a try/except statement to handle the error

Alternatively, you can use a try/except block to handle the error.

We try to access the list of the current iteration at index 1 , and if an IndexError is raised, we can handle it in the except block or continue to the next iteration.

# sys.argv [1] IndexError: list index out of range in Python

The sys.argv "IndexError: list index out of range in Python" occurs when we run a Python script without specifying values for the required command line arguments.

To solve the error, provide values for the required arguments, e.g. python main.py first second .

I ran the script with python main.py .

The sys.argv list contains the command line arguments that were passed to the Python script.

# Provide all of the required command line arguments

To solve the error, make sure to provide all of the required command line arguments when running the script, e.g. python main.py first second .

Notice that the first item in the list is always the name of the script.

It is operating system dependent if this is the full pathname or not.

# Check if the sys.argv list contains the index

If you don't have to always specify all of the command line arguments that your script tries to access, use an if statement to check if the sys.argv list contains the index that you are trying to access.

I ran the script as python main.py without providing any command line arguments, so the condition wasn't met and the else block ran.

We tried accessing the list item at index 1 which raised an IndexError exception.

You can handle the error or use the pass keyword in the except block.

# IndexError: pop index out of range in Python

The Python "IndexError: pop index out of range" occurs when we pass an index that doesn't exist in the list to the pop() method.

To solve the error, pass an index that exists to the method or call the pop() method without arguments to remove the last item from the list.

The list has a length of 3 . Since indexes in Python are zero-based, the first item in the list has an index of 0 , and the last an index of 2 .

If you need to remove the last item in the list, call the method without passing it an index.

The list.pop method removes the item at the given position in the list and returns it.

You can also use negative indices to count backward, e.g. my_list.pop(-1) removes the last item of the list, and my_list.pop(-2) removes the second-to-last item.

Alternatively, you can check if an item at the specified index exists before passing it to pop() .

This means that you can check if the list's length is greater than the index you are passing to pop() .

An alternative approach to handle the error is to use a try/except block.

If calling the pop() method with the provided index raises an IndexError , the except block is run, where we can handle the error or use the pass keyword to ignore it.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• IndexError: index 0 is out of bounds for axis 0 with size 0
• IndexError: invalid index to scalar variable in Python
• IndexError: pop from empty list in Python [Solved]
• Replacement index 1 out of range for positional args tuple
• IndexError: too many indices for array in Python [Solved]
• IndexError: tuple index out of range in Python [Solved]

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

Indexing in Python – A Complete Beginners Guide

Data structures in Python include lists, tuples, etc. These data structures can have multiple elements in them, each having some different properties but the problem is how to refer to a particular element from the hundreds of elements they contain. Here indexing comes into action. Indexing is a simple but fundamental concept that is important to learn before further processing with Python data structures.

This tutorial will explain everything you need to know about indexing in Python. But first, let’s take a quick look at iterables.

Prerequisite – What are Iterables?

Before we get started with indexing, let’s understand what iterables are and what is their main function. The knowledge of iterables is much needed to go behind indexing.

Iterables in Python

Iterables are a special type of objects in Python that you can iterate over. Meaning you can traverse through all the different elements or entities contained within the object. It can be easily achieved using the for loops .

Under the hood, what all these iterable items carry are two unique methods called __iter__() or __getitem__() that implement the Sequence Semantics .

Besides lists in Python, strings and tuples are also iterable.

Now that we know what Iterables are in Python. How is this related to indexing?

What is Indexing in Python?

Indexing in Python is a way to refer to the individual items within an iterable by their position. In other words, you can directly access your elements of choice within an iterable and do various operations depending on your needs.

Before we get into examples of Indexing in Python, there’s an important thing to Note:

In Python, objects are “zero-indexed” meaning the position count starts at zero. Many other programming languages follow the same pattern. So, if there are 5 elements present within a list. Then the first element (i.e. the leftmost element) holds the “zeroth” position, followed by the elements in the first, second, third, and fourth positions.

Python Index Method

The index of a specific item within a list can be revealed when the index() method is called on the list with the item name passed as an argument.

Where item is an element that index value we want to get.

Python Index Operator

The Python Index Operator is represented by opening and closing square brackets: []. The syntax, however, requires you to put a number inside the brackets.

Where n is just an integer number representing the position of the element we want to access.

We can see how our print function accesses different elements within our string object to get the specific characters we want.

Negative Indexing in Python

We’ve recently learned how to use indexing in Lists and Strings to get the specific items of our interest. Although in all our previous cases we’ve used a positive integer inside our index operator (the square brackets), it’s not necessarily needed to be that way.

Often, if we are interested in the last few elements of a list or maybe we just want to index the list from the opposite end, we can use negative integers. This process of indexing from the opposite end is called Negative Indexing.

Note: In negative Indexing, the last element is represented by -1 and not -0.

In this tutorial, we’ve learned that indexing is just a way of referencing the elements of an iterable. We have used the Python index() method to get the index of a particular element. We’ve also looked at the Python index operator and what negative indexing is. Hope you enjoyed the tutorial and learned how to implement indexing in your next project.

https://docs.python.org/3/tutorial/datastructures.html

• Documentation
• System Status

• Rollbar Academy

• Software Development
• Engineering Management
• Platform/Ops
• Customer Support
• Software Agency

• Low-Risk Release
• Production Code Quality
• DevOps Bridge
• Effective Testing & QA

How to Fix “IndexError: List Assignment Index Out of Range” in Python

Table of Contents

The IndexError: List Assignment Index Out of Range error occurs when you assign a value to an index that is beyond the valid range of indices in the list. As Python uses zero-based indexing, when you try to access an element at an index less than 0 or greater than or equal to the list’s length, you trigger this error.

It’s not as complicated as it sounds. Think of it this way: you have a row of ten mailboxes, numbered from 0 to 9. These mailboxes represent the list in Python. Now, if you try to put a letter into mailbox number 10, which doesn't exist, you'll face a problem. Similarly, if you try to put a letter into any negative number mailbox, you'll face the same issue because those mailboxes don't exist either.

The IndexError: List Assignment Index Out of Range error in Python is like trying to put a letter into a mailbox that doesn't exist in our row of mailboxes. Just as you can't access a non-existent mailbox, you can't assign a value to an index in a list that doesn't exist.

Let’s take a look at example code that raises this error and some strategies to prevent it from occurring in the first place.

Example of “IndexError: List Assignment Index Out of Range”

Remember, assigning a value at an index that is negative or out of bounds of the valid range of indices of the list raises the error.

How to resolve “IndexError: List Assignment Index Out of Range”

You can use methods such as append() or insert() to insert a new element into the list.

How to use the append() method

Use the append() method to add elements to extend the list properly and avoid out-of-range assignments.

How to use the insert() method

Use the insert() method to insert elements at a specific position instead of direct assignment to avoid out-of-range assignments.

Now one big advantage of using insert() is even if you specify an index position which is way out of range it won’t give any error and it will just append the element at the end of the list.

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Python errors easier than ever. Try it today !

Related Resources

How to Handle TypeError: Cannot Unpack Non-iterable Nonetype Objects in Python

How to Fix IndexError: string index out of range in Python

How to Fix Python’s “List Index Out of Range” Error in For Loops

"Rollbar allows us to go from alerting to impact analysis and resolution in a matter of minutes. Without it we would be flying blind."

Start continuously improving your code today.

• Link to facebook
• Link to linkedin
• Link to twitter
• Link to youtube
• Writing Tips

How to Create an Index in Microsoft Word

• 3-minute read
• 21st December 2018

Have you ever wondered who compiles the indexes at the end of books ? Traditionally, this has been a specialist profession . However, these days, you can add an index to a document yourself. In this post, for example, we’re looking at how to create an index in Microsoft Word.

When to Add an Index

Most documents don’t need an index. In fact, it is usually only book-length non-fiction that does! And even if you are writing a non-fiction book, indexing is often handled by the publisher.

However, if you want to self-publish a work of non-fiction – or if you are creating another long document such as a company handbook – you may want to add an index yourself. And this is where the indexing options in Microsoft Word become very useful. This process involves two steps:

• Marking terms that you want to appear in the index
• Generating the index itself

We’ll now look at how to create an index in more detail below.

How to Mark Entries

Most of the work of creating an index comes with marking text. This means going through the document to look for terms you want to include in the final index. To mark an entry:

Find this useful?

Subscribe to our newsletter and get writing tips from our editors straight to your inbox.

• Use the cursor to select the word/phrase you want to include in the index
• Go to References > Index on the main ribbon and click Mark Entry
• In the new dialogue box, select the options required
• Click Mark to mark the term selected or Mark All to mark every use of the term throughout the document

The options in the Mark Entry dialogue box mentioned above will let you:

• Link a Subentry (i.e., a similar term) to the main term
• Cross-reference a term with another index entry
• Control the page number format

Make sure to do this for every term that you want to include in the index. If you need to “unmark” a term, you will first need to turn on hidden text in Word. You will then be able to see, and if required remove, the index entry in curly brackets. Make sure to do this for all similar entries.

How to Create an Index

Once you have marked your entries, all that’s left is to create an index:

• Place the cursor where you want to create an index
• Go to References > Index and select Insert Index
• Select any required formatting options from the menu
• Click OK to insert an index in the selected location

Microsoft Word will generate an index based on your marked entries. If you change any of the marked entries, you can then update the index at the click of a button by going to References > Index > Update Index .

Share this article:

Post A New Comment

Got content that needs a quick turnaround? Let us polish your work. Explore our editorial business services.

6-minute read

How to Write a Nonprofit Grant Proposal

If you’re seeking funding to support your charitable endeavors as a nonprofit organization, you’ll need...

9-minute read

How to Use Infographics to Boost Your Presentation

Is your content getting noticed? Capturing and maintaining an audience’s attention is a challenge when...

8-minute read

Why Interactive PDFs Are Better for Engagement

Are you looking to enhance engagement and captivate your audience through your professional documents? Interactive...

7-minute read

Seven Key Strategies for Voice Search Optimization

Voice search optimization is rapidly shaping the digital landscape, requiring content professionals to adapt their...

4-minute read

Five Creative Ways to Showcase Your Digital Portfolio

Are you a creative freelancer looking to make a lasting impression on potential clients or...

How to Ace Slack Messaging for Contractors and Freelancers

Effective professional communication is an important skill for contractors and freelancers navigating remote work environments....

Make sure your writing is the best it can be with our expert English proofreading and editing.

• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Python Indexerror: list assignment index out of range Solution

In python, lists are mutable as the elements of a list can be modified. But if you try to modify a value whose index is greater than or equal to the length of the list then you will encounter an Indexerror: list assignment index out of range.  

Python Indexerror: list assignment index out of range Example

If ‘fruits’ is a list, fruits=[‘Apple’,’ Banana’,’ Guava’]and you try to modify fruits[5] then you will get an index error since the length of fruits list=3 which is less than index asked to modify for which is 5.

So, as you can see in the above example, we get an error when we try to modify an index that is not present in the list of fruits.

Method 1: Using insert() function

The insert(index, element) function takes two arguments, index and element, and adds a new element at the specified index.

Let’s see how you can add Mango to the list of fruits on index 1.

It is necessary to specify the index in the insert(index, element) function, otherwise, you will an error that the insert(index, element) function needed two arguments.

Method 2: Using append()

The append(element) function takes one argument element and adds a new element at the end of the list.

Let’s see how you can add Mango to the end of the list using the append(element) function.

Python IndexError FAQ

Q: what is an indexerror in python.

A: An IndexError is a common error that occurs when you try to access an element in a list, tuple, or other sequence using an index that is out of range. It means that the index you provided is either negative or greater than or equal to the length of the sequence.

Q: How can I fix an IndexError in Python?

A: To fix an IndexError, you can take the following steps:

• Check the index value: Make sure the index you’re using is within the valid range for the sequence. Remember that indexing starts from 0, so the first element is at index 0, the second at index 1, and so on.
• Verify the sequence length: Ensure that the sequence you’re working with has enough elements. If the sequence is empty, trying to access any index will result in an IndexError.
• Review loop conditions: If the IndexError occurs within a loop, check the loop conditions to ensure they are correctly set. Make sure the loop is not running more times than expected or trying to access an element beyond the sequence’s length.
• Use try-except: Wrap the code block that might raise an IndexError within a try-except block. This allows you to catch the exception and handle it gracefully, preventing your program from crashing.

Please Login to comment...

Similar reads.

• Python How-to-fix
• python-list

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Home » Microsoft Word » How to Create an Index in MS Word

How to Create an Index in MS Word

Many books contain an index at the end. This helps in easily locating words, keywords, and phrases in the book. MS Word offers a simple method of adding an index in a document. 

In this tutorial, we will show you how to:

• Select References for an Index Entry
• Insert the Index
• Update the Index

We will use simple, step-by-step instructions for creating an index in MS Word.

Let us begin.

Method #1: Select References for an Index Entry

This method prepares the words that will appear in the index.

Step #1: Open a Word Document

Open the Word document in which you want the index to appear.

Step #2: Select a reference

Select the words that you want to add as index entries.

Click on the References tab in the main menu bar to change the ribbon.

In the References ribbon, in the Index section, click on the Mark Entry icon.

Step #3: Enter a subentry

A Mark Index Entry dialog box will open.

Under Index, the box for Main entry: is already filled with the text you selected.

Optionally, you can add a subentry in the box next to Subentry:

Step #4: Enter options

Under Options, you can enter any of the following:

• Cross-reference: — Enter the cross-reference if necessary
• Current page — Default page entry for index
• Page range — You can set a page range (must be in the form of a bookmark).

For this tutorial, we have chosen the default, current page.

Step #5: Enter page number format

Optionally, you can show the page number in the index in bold and in italics.

Select and click on Bold and Italics under Page number format .

Step #6: Mark the index entry

Click the Mark button at the bottom.

The text in the document changes to show the index entry.

The dialog box stays open to allow selecting further references.

Step #7: Select the next reference

Select other words that you want as the next reference.

Step #8: Enter a subentry

Under Index, the box for Main entry: is already filled with the selected reference.

Step #9: Enter options

Under Options, you have the options of entering:

Step #10: Enter page number format

Optionally, you can show the page number in the index as bold and in italics.

Step #11: Mark the index entry

Click the Mark tab at the bottom.

Step #12: Select additional references

Repeat Step #7 – #11 for selecting additional references.

Once you have covered all references, click on the Close button to close the dialog box.

Method #2: Insert the Index

This method allows inserting the index anywhere in the document.

Open the Word document where you have already selected references for indexing.

Step #2: Select index location

Navigate to the location where you want the index to appear.

Note: You can position the index at the beginning or at the end of your document. For this tutorial, we will position the index at the end of the document.

Step #3: Insert the index

Type INDEX, and hit Enter on your keyboard .

In the top ribbon bar, in the section Index, click on the Insert Index icon.

The Index dialog box will open.

Click on the Index tab at the top.

Click on Right align page numbers .

Click on the OK button at the bottom.

Word creates the index.

Method #3: Update the Index

This method updates the index after you have made changes to your document.

Step #1: Open MS Word Document

Open an MS Word document that has an index.

Navigate to the index.

Step #2: Update the index

Click anywhere within the index.

In the References ribbon, in the Index section, click on the Update Index icon.

Word updates the index to reflect any change in the document.

We have shown you an easy way of creating and updating an index in MS Word. Use our method to create useful indexes for your documents.

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

How to Create an Index in Word: A Step-by-Step Guide for Beginners

Creating an index in Word is simpler than it sounds. First, you’ll need to mark the entries you want to include in your index. Then, you’ll generate the index itself. By following these steps, you can create a professional-looking index that helps readers find key information quickly.

Step by Step Tutorial: How to Create an Index in Word

Creating an index in Word involves a couple of straightforward steps to help make your document more user-friendly. Here’s how you can do it:

Step 1: Mark the Entries

Highlight the text you want to include in the index, then go to the "References" tab and click “Mark Entry.”

Marking entries is like putting a flag on important sections of your document. This lets Word know which parts to include when it builds the index later. You can mark multiple entries by selecting different text portions one by one.

Step 2: Choose Index Options

Go back to the "References" tab and select "Insert Index." Customize the appearance and format of your index.

This step is where you get to decide how your index will look. You can choose from different styles, formats, and layouts to make sure the index fits with the rest of your document. This option also lets you specify how many columns the index should have.

Step 3: Update the Index

Whenever you make changes to your document, go to the "References" tab and click “Update Index” to refresh it.

Updating the index ensures that all the new entries you’ve marked will be included. It’s a crucial step to keep the index current, especially if you’ve added or removed significant chunks of text.

Step 4: Review the Index

Carefully review the index to make sure all entries are correct and complete.

This step involves scrolling through the index and checking for any errors or omissions. It’s your chance to catch any mistakes before you finalize the document.

Step 5: Finalize the Document

Once you’re satisfied with the index, save the document to preserve all the changes.

After finalizing, your document is ready for distribution. Saving ensures that all your hard work in creating the index is retained.

After completing these steps, your document will have a comprehensive index that makes it easy for readers to locate important information quickly and efficiently.

Tips for Creating an Index in Word

• Use Consistent Terminology : Ensure that the terms you mark for the index are consistent throughout the document.
• Be Selective : Only mark the most important entries to keep the index concise and useful.
• Double-Check Spelling : Make sure all marked entries are spelled correctly to avoid confusion.
• Utilize Subentries : Use subentries for more detailed indexing. For example, "Animals" can have subentries like "Dogs" and "Cats."
• Keep Updating : Remember to update the index regularly as you make changes to your document.

Frequently Asked Questions

How do i mark multiple entries at once.

You can’t highlight multiple sections simultaneously, but you can quickly mark several entries one after the other by using the "Mark Entry" dialog box.

Can I change the format of my index after creating it?

Yes, you can go back to the "Insert Index" options to alter the format anytime.

What if I make changes to the document after creating the index?

Simply go to the "References" tab and click “Update Index” to refresh your index with the latest changes.

How can I remove an entry from the index?

Delete the XE (Index Entry) field code for that entry, then update the index.

Can I create an index in a shared document?

Yes, but make sure all collaborators are aware when changes are made, so the index can be updated accordingly.

Summary of Steps

• Mark the Entries.
• Choose Index Options.
• Update the Index.
• Review the Index.
• Finalize the Document.

Creating an index in Word can significantly enhance the readability and navigability of your document. By marking important entries and customizing your index, you can provide a useful roadmap for readers to follow. Remember, consistency is key, and always keep your index updated to reflect any changes you make. With these steps and tips, you’re well on your way to mastering the art of creating an index in Word. So, go ahead and give it a try. Your readers will thank you!

Kermit Matthews is a freelance writer based in Philadelphia, Pennsylvania with more than a decade of experience writing technology guides. He has a Bachelor’s and Master’s degree in Computer Science and has spent much of his professional career in IT management.

He specializes in writing content about iPhones, Android devices, Microsoft Office, and many other popular applications and devices.

Read his full bio here .

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)
• Click to email a link to a friend (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on Pinterest (Opens in new window)
• Click to share on Tumblr (Opens in new window)

Related posts:

• How to Make Index Cards in Google Docs: A Step-by-Step Guide
• Fixing Python List Assignments: How to Avoid ‘Index Out of Range’ Error
• How to Curve Text in Word for Office 365
• How to Get a Microsoft Word Character Count in Word 2016, 2019, or Word for Office 365
• How to Download a Microsoft Word Document on Mac: A Step-by-Step Guide
• How to Remove Section Breaks in Word Documents
• Check Mark in Word – How to Add One
• How to Make a Check Mark in Google Sheets: A Step-by-Step Guide
• How to Quickly Find a Circular Reference in Excel: A Step-by-Step Guide
• How to Use Microsoft Word 2007: A Comprehensive Guide
• How to Unsort in Google Sheets: A Step-by-Step Guide
• How to Open a PDF in Microsoft Word: A Step-by-Step Guide
• How to Get Out of Compatibility Mode in MS Word: A Step-by-Step Guide
• How to Create a Table in Microsoft Word for Office 365: A Step-by-Step Guide
• How to Clean Registry Windows 11: A Step-by-Step Guide for Beginners
• How to Put a Link in Word
• How to Insert a Hyperlink in Microsoft Word: A Step-by-Step Guide
• How to Edit Word Document on iPhone 13
• How to Open a Google Doc in Microsoft Word: A Step-by-Step Guide
• How to Redline a Document in Microsoft Word: Step-by-Step Guide

pandas.DataFrame.set_index #

Set the DataFrame index using existing columns.

Set the DataFrame index (row labels) using one or more existing columns or arrays (of the correct length). The index can replace the existing index or expand on it.

This parameter can be either a single column key, a single array of the same length as the calling DataFrame, or a list containing an arbitrary combination of column keys and arrays. Here, “array” encompasses Series , Index , np.ndarray , and instances of Iterator .

Delete columns to be used as the new index.

Whether to append columns to existing index.

Whether to modify the DataFrame rather than creating a new one.

Check the new index for duplicates. Otherwise defer the check until necessary. Setting to False will improve the performance of this method.

Changed row labels or None if inplace=True .

Opposite of set_index.

Change to new indices or expand indices.

Change to same indices as other DataFrame.

Set the index to become the ‘month’ column:

Create a MultiIndex using columns ‘year’ and ‘month’:

Create a MultiIndex using an Index and a column:

Create a MultiIndex using two Series:

Create and update an index

An index lists the terms and topics that are discussed in a document, along with the pages that they appear on. To create an index, you mark the index entries by providing the name of the main entry and the cross-reference in your document, and then you build the index.

You can create an index entry for an individual word, phrase, or symbol, for a topic that spans a range of pages, or that refers to another entry, such as "Transportation. See Bicycles." When you select text and mark it as an index entry, Word adds a special XE (Index Entry) field that includes the marked main entry and any cross-reference information that you choose to include.

After you mark all the index entries, you choose an index design and build the finished index. Word collects the index entries, sorts them alphabetically, references their page numbers, finds and removes duplicate entries from the same page, and displays the index in the document.

Mark the entries

These steps show you how to mark words or phrases for your index, but you can also Mark index entries for text that spans a range of pages.

Select the text you’d like to use as an index entry, or just click where you want to insert the entry.

You can add a second-level in the Subentry box. If you need a third level, follow the subentry text with a colon.

To create a cross-reference to another entry, select  Cross-reference under Options , and then type the text for the other entry in the box.

To format the page numbers that will appear in the index, select the Bold check box or Italic check box below Page number format .

Select  Mark to mark the index entry. To mark this text everywhere it shows up in the document, select  Mark All .

To mark additional index entries, select the text, selectin the Mark Index Entry dialog box, and then repeat steps 3 and 4.

Create the index

After you mark the entries, you’re ready to insert the index into your document.

Click where you want to add the index.

You can change the overall look of the index by choosing from the Formats dropdown menu. A preview is displayed in the window to the top left.

Select OK .

Edit or format an index entry and update the index

If you mark more entries after creating your index, you’ll need to update the index to see them.

Find the XE field for the entry that you want to change, for example, { XE "Callisto" \t " See Moons" } .

To edit or format an index entry, change the text inside the quotation marks.

To update the index, click the index, and then press F9. Or go to  References >  Update  Index.

If you find an error in the index, locate the index entry that you want to change, make the change, and then update the index.

Delete an index entry and update the index

Select the entire index entry field, including the braces ( {} ), and then press DELETE.

To update the index, click the index, and then press F9. Or go to  References >  Update Index .

Need more help?

Want more options.

Explore subscription benefits, browse training courses, learn how to secure your device, and more.

Microsoft 365 subscription benefits

Microsoft 365 training

Microsoft security

Accessibility center

Communities help you ask and answer questions, give feedback, and hear from experts with rich knowledge.

Ask the Microsoft Community

Microsoft Tech Community

Windows Insiders

Microsoft 365 Insiders

Was this information helpful?

Thank you for your feedback.

You're signed out

Sign in to ask questions, follow content, and engage with the Community

• Canvas Instructor
• Instructor Guide

How do I use the Assignments Index Page?

• Subscribe to RSS Feed
• Printer Friendly Page
• Report Inappropriate Content

in Instructor Guide

Note: You can only embed guides in Canvas courses. Embedding on other sites is not supported.

Community Help

View our top guides and resources:.

To participate in the Instructure Community, you need to sign up or log in:

Indexing on ndarrays #

Indexing routines

ndarrays can be indexed using the standard Python x[obj] syntax, where x is the array and obj the selection. There are different kinds of indexing available depending on obj : basic indexing, advanced indexing and field access.

Most of the following examples show the use of indexing when referencing data in an array. The examples work just as well when assigning to an array. See Assigning values to indexed arrays for specific examples and explanations on how assignments work.

Note that in Python, x[(exp1, exp2, ..., expN)] is equivalent to x[exp1, exp2, ..., expN] ; the latter is just syntactic sugar for the former.

Basic indexing #

Single element indexing #.

Single element indexing works exactly like that for other standard Python sequences. It is 0-based, and accepts negative indices for indexing from the end of the array.

It is not necessary to separate each dimension’s index into its own set of square brackets.

Note that if one indexes a multidimensional array with fewer indices than dimensions, one gets a subdimensional array. For example:

That is, each index specified selects the array corresponding to the rest of the dimensions selected. In the above example, choosing 0 means that the remaining dimension of length 5 is being left unspecified, and that what is returned is an array of that dimensionality and size. It must be noted that the returned array is a view , i.e., it is not a copy of the original, but points to the same values in memory as does the original array. In this case, the 1-D array at the first position (0) is returned. So using a single index on the returned array, results in a single element being returned. That is:

So note that x[0, 2] == x[0][2] though the second case is more inefficient as a new temporary array is created after the first index that is subsequently indexed by 2.

NumPy uses C-order indexing. That means that the last index usually represents the most rapidly changing memory location, unlike Fortran or IDL, where the first index represents the most rapidly changing location in memory. This difference represents a great potential for confusion.

Slicing and striding #

Basic slicing extends Python’s basic concept of slicing to N dimensions. Basic slicing occurs when obj is a slice object (constructed by start:stop:step notation inside of brackets), an integer, or a tuple of slice objects and integers. Ellipsis and newaxis objects can be interspersed with these as well.

The simplest case of indexing with N integers returns an array scalar representing the corresponding item. As in Python, all indices are zero-based: for the i -th index \(n_i\) , the valid range is \(0 \le n_i < d_i\) where \(d_i\) is the i -th element of the shape of the array. Negative indices are interpreted as counting from the end of the array ( i.e. , if \(n_i < 0\) , it means \(n_i + d_i\) ).

All arrays generated by basic slicing are always views of the original array.

NumPy slicing creates a view instead of a copy as in the case of built-in Python sequences such as string, tuple and list. Care must be taken when extracting a small portion from a large array which becomes useless after the extraction, because the small portion extracted contains a reference to the large original array whose memory will not be released until all arrays derived from it are garbage-collected. In such cases an explicit copy() is recommended.

The standard rules of sequence slicing apply to basic slicing on a per-dimension basis (including using a step index). Some useful concepts to remember include:

The basic slice syntax is i:j:k where i is the starting index, j is the stopping index, and k is the step ( \(k\neq0\) ). This selects the m elements (in the corresponding dimension) with index values i , i + k , …, i + (m - 1) k where \(m = q + (r\neq0)\) and q and r are the quotient and remainder obtained by dividing j - i by k : j - i = q k + r , so that i + (m - 1) k < j . For example:

Negative i and j are interpreted as n + i and n + j where n is the number of elements in the corresponding dimension. Negative k makes stepping go towards smaller indices. From the above example:

Assume n is the number of elements in the dimension being sliced. Then, if i is not given it defaults to 0 for k > 0 and n - 1 for k < 0 . If j is not given it defaults to n for k > 0 and -n-1 for k < 0 . If k is not given it defaults to 1. Note that :: is the same as : and means select all indices along this axis. From the above example:

If the number of objects in the selection tuple is less than N , then : is assumed for any subsequent dimensions. For example:

An integer, i , returns the same values as i:i+1 except the dimensionality of the returned object is reduced by 1. In particular, a selection tuple with the p -th element an integer (and all other entries : ) returns the corresponding sub-array with dimension N - 1 . If N = 1 then the returned object is an array scalar. These objects are explained in Scalars .

If the selection tuple has all entries : except the p -th entry which is a slice object i:j:k , then the returned array has dimension N formed by stacking, along the p -th axis, the sub-arrays returned by integer indexing of elements i , i+k , …, i + (m - 1) k < j .

Basic slicing with more than one non- : entry in the slicing tuple, acts like repeated application of slicing using a single non- : entry, where the non- : entries are successively taken (with all other non- : entries replaced by : ). Thus, x[ind1, ..., ind2,:] acts like x[ind1][..., ind2, :] under basic slicing.

The above is not true for advanced indexing.

You may use slicing to set values in the array, but (unlike lists) you can never grow the array. The size of the value to be set in x[obj] = value must be (broadcastable to) the same shape as x[obj] .

A slicing tuple can always be constructed as obj and used in the x[obj] notation. Slice objects can be used in the construction in place of the [start:stop:step] notation. For example, x[1:10:5, ::-1] can also be implemented as obj = (slice(1, 10, 5), slice(None, None, -1)); x[obj] . This can be useful for constructing generic code that works on arrays of arbitrary dimensions. See Dealing with variable numbers of indices within programs for more information.

Dimensional indexing tools #

There are some tools to facilitate the easy matching of array shapes with expressions and in assignments.

Ellipsis expands to the number of : objects needed for the selection tuple to index all dimensions. In most cases, this means that the length of the expanded selection tuple is x.ndim . There may only be a single ellipsis present. From the above example:

This is equivalent to:

Each newaxis object in the selection tuple serves to expand the dimensions of the resulting selection by one unit-length dimension. The added dimension is the position of the newaxis object in the selection tuple. newaxis is an alias for None , and None can be used in place of this with the same result. From the above example:

This can be handy to combine two arrays in a way that otherwise would require explicit reshaping operations. For example:

Advanced indexing #

Advanced indexing is triggered when the selection object, obj , is a non-tuple sequence object, an ndarray (of data type integer or bool), or a tuple with at least one sequence object or ndarray (of data type integer or bool). There are two types of advanced indexing: integer and Boolean.

Advanced indexing always returns a copy of the data (contrast with basic slicing that returns a view ).

The definition of advanced indexing means that x[(1, 2, 3),] is fundamentally different than x[(1, 2, 3)] . The latter is equivalent to x[1, 2, 3] which will trigger basic selection while the former will trigger advanced indexing. Be sure to understand why this occurs.

Integer array indexing #

Integer array indexing allows selection of arbitrary items in the array based on their N -dimensional index. Each integer array represents a number of indices into that dimension.

Negative values are permitted in the index arrays and work as they do with single indices or slices:

If the index values are out of bounds then an IndexError is thrown:

When the index consists of as many integer arrays as dimensions of the array being indexed, the indexing is straightforward, but different from slicing.

Advanced indices always are broadcast and iterated as one :

Note that the resulting shape is identical to the (broadcast) indexing array shapes ind_1, ..., ind_N . If the indices cannot be broadcast to the same shape, an exception IndexError: shape mismatch: indexing arrays could not be broadcast together with shapes... is raised.

Indexing with multidimensional index arrays tend to be more unusual uses, but they are permitted, and they are useful for some problems. We’ll start with the simplest multidimensional case:

In this case, if the index arrays have a matching shape, and there is an index array for each dimension of the array being indexed, the resultant array has the same shape as the index arrays, and the values correspond to the index set for each position in the index arrays. In this example, the first index value is 0 for both index arrays, and thus the first value of the resultant array is y[0, 0] . The next value is y[2, 1] , and the last is y[4, 2] .

If the index arrays do not have the same shape, there is an attempt to broadcast them to the same shape. If they cannot be broadcast to the same shape, an exception is raised:

The broadcasting mechanism permits index arrays to be combined with scalars for other indices. The effect is that the scalar value is used for all the corresponding values of the index arrays:

Jumping to the next level of complexity, it is possible to only partially index an array with index arrays. It takes a bit of thought to understand what happens in such cases. For example if we just use one index array with y:

It results in the construction of a new array where each value of the index array selects one row from the array being indexed and the resultant array has the resulting shape (number of index elements, size of row).

In general, the shape of the resultant array will be the concatenation of the shape of the index array (or the shape that all the index arrays were broadcast to) with the shape of any unused dimensions (those not indexed) in the array being indexed.

From each row, a specific element should be selected. The row index is just [0, 1, 2] and the column index specifies the element to choose for the corresponding row, here [0, 1, 0] . Using both together the task can be solved using advanced indexing:

To achieve a behaviour similar to the basic slicing above, broadcasting can be used. The function ix_ can help with this broadcasting. This is best understood with an example.

From a 4x3 array the corner elements should be selected using advanced indexing. Thus all elements for which the column is one of [0, 2] and the row is one of [0, 3] need to be selected. To use advanced indexing one needs to select all elements explicitly . Using the method explained previously one could write:

However, since the indexing arrays above just repeat themselves, broadcasting can be used (compare operations such as rows[:, np.newaxis] + columns ) to simplify this:

This broadcasting can also be achieved using the function ix_ :

Note that without the np.ix_ call, only the diagonal elements would be selected:

This difference is the most important thing to remember about indexing with multiple advanced indices.

A real-life example of where advanced indexing may be useful is for a color lookup table where we want to map the values of an image into RGB triples for display. The lookup table could have a shape (nlookup, 3). Indexing such an array with an image with shape (ny, nx) with dtype=np.uint8 (or any integer type so long as values are with the bounds of the lookup table) will result in an array of shape (ny, nx, 3) where a triple of RGB values is associated with each pixel location.

Boolean array indexing #

This advanced indexing occurs when obj is an array object of Boolean type, such as may be returned from comparison operators. A single boolean index array is practically identical to x[obj.nonzero()] where, as described above, obj.nonzero() returns a tuple (of length obj.ndim ) of integer index arrays showing the True elements of obj . However, it is faster when obj.shape == x.shape .

If obj.ndim == x.ndim , x[obj] returns a 1-dimensional array filled with the elements of x corresponding to the True values of obj . The search order will be row-major , C-style. An index error will be raised if the shape of obj does not match the corresponding dimensions of x , regardless of whether those values are True or False .

A common use case for this is filtering for desired element values. For example, one may wish to select all entries from an array which are not numpy.nan :

Or wish to add a constant to all negative elements:

In general if an index includes a Boolean array, the result will be identical to inserting obj.nonzero() into the same position and using the integer array indexing mechanism described above. x[ind_1, boolean_array, ind_2] is equivalent to x[(ind_1,) + boolean_array.nonzero() + (ind_2,)] .

If there is only one Boolean array and no integer indexing array present, this is straightforward. Care must only be taken to make sure that the boolean index has exactly as many dimensions as it is supposed to work with.

In general, when the boolean array has fewer dimensions than the array being indexed, this is equivalent to x[b, ...] , which means x is indexed by b followed by as many : as are needed to fill out the rank of x. Thus the shape of the result is one dimension containing the number of True elements of the boolean array, followed by the remaining dimensions of the array being indexed:

Here the 4th and 5th rows are selected from the indexed array and combined to make a 2-D array.

From an array, select all rows which sum up to less or equal two:

Combining multiple Boolean indexing arrays or a Boolean with an integer indexing array can best be understood with the obj.nonzero() analogy. The function ix_ also supports boolean arrays and will work without any surprises.

Use boolean indexing to select all rows adding up to an even number. At the same time columns 0 and 2 should be selected with an advanced integer index. Using the ix_ function this can be done with:

Without the np.ix_ call, only the diagonal elements would be selected.

Or without np.ix_ (compare the integer array examples):

Use a 2-D boolean array of shape (2, 3) with four True elements to select rows from a 3-D array of shape (2, 3, 5) results in a 2-D result of shape (4, 5):

Combining advanced and basic indexing #

When there is at least one slice ( : ), ellipsis ( ... ) or newaxis in the index (or the array has more dimensions than there are advanced indices), then the behaviour can be more complicated. It is like concatenating the indexing result for each advanced index element.

In the simplest case, there is only a single advanced index combined with a slice. For example:

In effect, the slice and index array operation are independent. The slice operation extracts columns with index 1 and 2, (i.e. the 2nd and 3rd columns), followed by the index array operation which extracts rows with index 0, 2 and 4 (i.e the first, third and fifth rows). This is equivalent to:

A single advanced index can, for example, replace a slice and the result array will be the same. However, it is a copy and may have a different memory layout. A slice is preferable when it is possible. For example:

The easiest way to understand a combination of multiple advanced indices may be to think in terms of the resulting shape. There are two parts to the indexing operation, the subspace defined by the basic indexing (excluding integers) and the subspace from the advanced indexing part. Two cases of index combination need to be distinguished:

The advanced indices are separated by a slice, Ellipsis or newaxis . For example x[arr1, :, arr2] .

The advanced indices are all next to each other. For example x[..., arr1, arr2, :] but not x[arr1, :, 1] since 1 is an advanced index in this regard.

In the first case, the dimensions resulting from the advanced indexing operation come first in the result array, and the subspace dimensions after that. In the second case, the dimensions from the advanced indexing operations are inserted into the result array at the same spot as they were in the initial array (the latter logic is what makes simple advanced indexing behave just like slicing).

Suppose x.shape is (10, 20, 30) and ind is a (2, 3, 4)-shaped indexing intp array, then result = x[..., ind, :] has shape (10, 2, 3, 4, 30) because the (20,)-shaped subspace has been replaced with a (2, 3, 4)-shaped broadcasted indexing subspace. If we let i, j, k loop over the (2, 3, 4)-shaped subspace then result[..., i, j, k, :] = x[..., ind[i, j, k], :] . This example produces the same result as x.take(ind, axis=-2) .

Let x.shape be (10, 20, 30, 40, 50) and suppose ind_1 and ind_2 can be broadcast to the shape (2, 3, 4). Then x[:, ind_1, ind_2] has shape (10, 2, 3, 4, 40, 50) because the (20, 30)-shaped subspace from X has been replaced with the (2, 3, 4) subspace from the indices. However, x[:, ind_1, :, ind_2] has shape (2, 3, 4, 10, 30, 50) because there is no unambiguous place to drop in the indexing subspace, thus it is tacked-on to the beginning. It is always possible to use .transpose() to move the subspace anywhere desired. Note that this example cannot be replicated using take .

Slicing can be combined with broadcasted boolean indices:

Field access #

Structured arrays

If the ndarray object is a structured array the fields of the array can be accessed by indexing the array with strings, dictionary-like.

Indexing x['field-name'] returns a new view to the array, which is of the same shape as x (except when the field is a sub-array) but of data type x.dtype['field-name'] and contains only the part of the data in the specified field. Also, record array scalars can be “indexed” this way.

Indexing into a structured array can also be done with a list of field names, e.g. x[['field-name1', 'field-name2']] . As of NumPy 1.16, this returns a view containing only those fields. In older versions of NumPy, it returned a copy. See the user guide section on Structured arrays for more information on multifield indexing.

If the accessed field is a sub-array, the dimensions of the sub-array are appended to the shape of the result. For example:

Flat iterator indexing #

x.flat returns an iterator that will iterate over the entire array (in C-contiguous style with the last index varying the fastest). This iterator object can also be indexed using basic slicing or advanced indexing as long as the selection object is not a tuple. This should be clear from the fact that x.flat is a 1-dimensional view. It can be used for integer indexing with 1-dimensional C-style-flat indices. The shape of any returned array is therefore the shape of the integer indexing object.

Assigning values to indexed arrays #

As mentioned, one can select a subset of an array to assign to using a single index, slices, and index and mask arrays. The value being assigned to the indexed array must be shape consistent (the same shape or broadcastable to the shape the index produces). For example, it is permitted to assign a constant to a slice:

or an array of the right size:

Note that assignments may result in changes if assigning higher types to lower types (like floats to ints) or even exceptions (assigning complex to floats or ints):

Unlike some of the references (such as array and mask indices) assignments are always made to the original data in the array (indeed, nothing else would make sense!). Note though, that some actions may not work as one may naively expect. This particular example is often surprising to people:

Where people expect that the 1st location will be incremented by 3. In fact, it will only be incremented by 1. The reason is that a new array is extracted from the original (as a temporary) containing the values at 1, 1, 3, 1, then the value 1 is added to the temporary, and then the temporary is assigned back to the original array. Thus the value of the array at x[1] + 1 is assigned to x[1] three times, rather than being incremented 3 times.

Dealing with variable numbers of indices within programs #

The indexing syntax is very powerful but limiting when dealing with a variable number of indices. For example, if you want to write a function that can handle arguments with various numbers of dimensions without having to write special case code for each number of possible dimensions, how can that be done? If one supplies to the index a tuple, the tuple will be interpreted as a list of indices. For example:

So one can use code to construct tuples of any number of indices and then use these within an index.

Slices can be specified within programs by using the slice() function in Python. For example:

Likewise, ellipsis can be specified by code by using the Ellipsis object:

For this reason, it is possible to use the output from the np.nonzero() function directly as an index since it always returns a tuple of index arrays.

Because of the special treatment of tuples, they are not automatically converted to an array as a list would be. As an example:

Detailed notes #

These are some detailed notes, which are not of importance for day to day indexing (in no particular order):

The native NumPy indexing type is intp and may differ from the default integer array type. intp is the smallest data type sufficient to safely index any array; for advanced indexing it may be faster than other types.

For advanced assignments, there is in general no guarantee for the iteration order. This means that if an element is set more than once, it is not possible to predict the final result.

An empty (tuple) index is a full scalar index into a zero-dimensional array. x[()] returns a scalar if x is zero-dimensional and a view otherwise. On the other hand, x[...] always returns a view.

If a zero-dimensional array is present in the index and it is a full integer index the result will be a scalar and not a zero-dimensional array. (Advanced indexing is not triggered.)

When an ellipsis ( ... ) is present but has no size (i.e. replaces zero : ) the result will still always be an array. A view if no advanced index is present, otherwise a copy.

The nonzero equivalence for Boolean arrays does not hold for zero dimensional boolean arrays.

When the result of an advanced indexing operation has no elements but an individual index is out of bounds, whether or not an IndexError is raised is undefined (e.g. x[[], [123]] with 123 being out of bounds).

When a casting error occurs during assignment (for example updating a numerical array using a sequence of strings), the array being assigned to may end up in an unpredictable partially updated state. However, if any other error (such as an out of bounds index) occurs, the array will remain unchanged.

The memory layout of an advanced indexing result is optimized for each indexing operation and no particular memory order can be assumed.

When using a subclass (especially one which manipulates its shape), the default ndarray.__setitem__ behaviour will call __getitem__ for basic indexing but not for advanced indexing. For such a subclass it may be preferable to call ndarray.__setitem__ with a base class ndarray view on the data. This must be done if the subclasses __getitem__ does not return views.

• Word Training

How to Make an Index in Word

How to Create and Update an Index in Word

Word Training Features:

Interactive bite-sized lessons

Get Certified

Accurate skill assessments

Customizable, LMS-ready content

4.9 out of 5 on G2

An index can usually be found at the end of a document, listing the key words and phrases in a document, along with the page numbers they appear on. There are two steps involved in creating an index: defining which words you want to appear in the index and then inserting the index.

Insert an Index Entry

• Select the text you want to include in the index.
• Click the References tab.

The Mark Index Entry dialog box opens, where you can set up how the index entry works. The main entry field is filled with the selected text, and you can also add a subentry that will appear below the main entry.

• Adjust the index entry’s settings and choose an index entry option:
• Cross-reference: Adds a reference to another index entry, instead of listing the current page number.
• Current page: Lists the current page number for the selected index entry. This is the default option.
• Page range: Lists the range of pages that are included in the bookmark that you click in the Bookmark list. Before using this option, you’ll need to create a bookmark of the selected range.

Clicking Mark will create an index entry for the selected instance of the word. Clicking Mark All will instead create an index entry for every instance of the selected word throughout the document.

Once you mark an entry, formatting marks will be displayed so that you can see the hidden text that marks index entries. The window remains open, so you can continue to mark index entries throughout the document.

• Repeat the process for your other index entries.

Index entries are invisible and will not be printed. However, you can see them when the paragraph marks are turned on.

Insert an Index

Once index entries have been marked, you’re ready to insert the index.

• Click in your document where you want to insert an index.

Indexes usually appear at the end of a document and can take up a lot of space, so a blank page at the end is ideal.

The Index dialog box opens, where you can set up how the index will appear.

You can choose whether to right align page numbers and select a tab leader that appears between text and page numbers. You can also select whether to use a document’s formatting theme or select another one.

You can choose whether subentries will be indented below the main entry or shown run-in style in a paragraph below the main entry.

• Customize the appearance and behavior of the index.

Any changes you make to the index appearance will be shown in the Print Preview.

The index is inserted, automatically filling itself out with all the index entries in the document.

Update an Index

When you insert an index, it automatically adds every index entry in the document. If you add or modify index entries after the index is created, you’ll need to update the index.

• Click anywhere in the index.

The index is updated, adding any newly created entries while updating the page numbers for any entries that may have moved.

FREE Quick Reference

Free to distribute with our compliments; we hope you will consider our paid training.

• LinkedIn-ready certificate
• Skill assessments
• Bite-sized, interactive lessons
• Saved progress

• Share full article

Advertisement

Supported by

Southwest Airlines Will End Its Longstanding Open-Seating Policy

The airline said it was scrapping its trademark, 50-year tradition of offering open seating, where passengers choose seats once they have boarded the plane.

By Jenny Gross and Danielle Kaye

Southwest Airlines will start assigning seats to passengers, ending its longstanding policy of allowing passengers to pick their seats once they have boarded, the airline said on Thursday.

The new procedure will be implemented to increase revenue and in response to feedback from customers, 80 percent of whom report preferring an assigned seat, Southwest said.

“This is the right choice — at the right time — for our customers, our people and our shareholders,” said Bob Jordan, the president and chief executive of Southwest.

Even though the airline has been known for its unique seating model for more than 50 years, preferences have evolved, with more customers taking longer flights where they prefer a seat assignment, the statement said. The new policy was reported earlier by The Wall Street Journal .

The changes bring Southwest, which for years has distinguished itself by offering low prices and a simple business approach, more in line with conventional airlines like American Airlines and United Airlines.

Southwest makes a little less than $1 billion from fees it charges for the ability to board early and “ancillary” services, Mr. Jordan said Thursday on a conference call with analysts to discuss the company’s second quarter results. The company expects that earnings from the move to assigned seating and offering seats with extra legroom will be “substantially north of that,” he said.

We are having trouble retrieving the article content.

Please enable JavaScript in your browser settings.

Thank you for your patience while we verify access. If you are in Reader mode please exit and  log into  your Times account, or  subscribe  for all of The Times.

Thank you for your patience while we verify access.

Already a subscriber?  Log in .

Want all of The Times?  Subscribe .

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

JavaScript ( JS ) is a lightweight interpreted (or just-in-time compiled) programming language with first-class functions . While it is most well-known as the scripting language for Web pages, many non-browser environments also use it, such as Node.js , Apache CouchDB and Adobe Acrobat . JavaScript is a prototype-based , multi-paradigm, single-threaded , dynamic language, supporting object-oriented, imperative, and declarative (e.g. functional programming) styles.

JavaScript's dynamic capabilities include runtime object construction, variable parameter lists, function variables, dynamic script creation (via eval ), object introspection (via for...in and Object utilities ), and source-code recovery (JavaScript functions store their source text and can be retrieved through toString() ).

This section is dedicated to the JavaScript language itself, and not the parts that are specific to Web pages or other host environments. For information about APIs that are specific to Web pages, please see Web APIs and DOM .

The standards for JavaScript are the ECMAScript Language Specification (ECMA-262) and the ECMAScript Internationalization API specification (ECMA-402). As soon as one browser implements a feature, we try to document it. This means that cases where some proposals for new ECMAScript features have already been implemented in browsers, documentation and examples in MDN articles may use some of those new features. Most of the time, this happens between the stages 3 and 4, and is usually before the spec is officially published.

Do not confuse JavaScript with the Java programming language — JavaScript is not "Interpreted Java" . Both "Java" and "JavaScript" are trademarks or registered trademarks of Oracle in the U.S. and other countries. However, the two programming languages have very different syntax, semantics, and use.

JavaScript documentation of core language features (pure ECMAScript , for the most part) includes the following:

• The JavaScript guide
• The JavaScript reference

For more information about JavaScript specifications and related technologies, see JavaScript technologies overview .

Learn how to program in JavaScript with guides and tutorials.

For complete beginners

Head over to our Learning Area JavaScript topic if you want to learn JavaScript but have no previous experience with JavaScript or programming. The complete modules available there are as follows:

Answers some fundamental questions such as "what is JavaScript?", "what does it look like?", and "what can it do?", along with discussing key JavaScript features such as variables, strings, numbers, and arrays.

Continues our coverage of JavaScript's key fundamental features, turning our attention to commonly-encountered types of code blocks such as conditional statements, loops, functions, and events.

The object-oriented nature of JavaScript is important to understand if you want to go further with your knowledge of the language and write more efficient code, therefore we've provided this module to help you.

Discusses asynchronous JavaScript, why it is important, and how it can be used to effectively handle potential blocking operations such as fetching resources from a server.

Explores what APIs are, and how to use some of the most common APIs you'll come across often in your development work.

JavaScript guide

A much more detailed guide to the JavaScript language, aimed at those with previous programming experience either in JavaScript or another language.

Intermediate

JavaScript frameworks are an essential part of modern front-end web development, providing developers with proven tools for building scalable, interactive web applications. This module gives you some fundamental background knowledge about how client-side frameworks work and how they fit into your toolset, before moving on to a series of tutorials covering some of today's most popular ones.

An overview of the basic syntax and semantics of JavaScript for those coming from other programming languages to get up to speed.

Overview of available data structures in JavaScript.

JavaScript provides three different value comparison operations: strict equality using === , loose equality using == , and the Object.is() method.

How different methods that visit a group of object properties one-by-one handle the enumerability and ownership of properties.

A closure is the combination of a function and the lexical environment within which that function was declared.

Explanation of the widely misunderstood and underestimated prototype-based inheritance.

Memory life cycle and garbage collection in JavaScript.

JavaScript has a runtime model based on an "event loop".

Browse the complete JavaScript reference documentation.

Get to know standard built-in objects Array , Boolean , Date , Error , Function , JSON , Math , Number , Object , RegExp , String , Map , Set , WeakMap , WeakSet , and others.

Learn more about the behavior of JavaScript's operators instanceof , typeof , new , this , the operator precedence , and more.

Learn how do-while , for-in , for-of , try-catch , let , var , const , if-else , switch , and more JavaScript statements and keywords work.

Learn how to work with JavaScript's functions to develop your applications.

JavaScript classes are the most appropriate way to do object-oriented programming.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Pandas dataframe - how to assign index?

It gives me a table consists of generated rand #s:

However, I would like to have labels for the rows instead of 0, 1, ...5, I tried

But as expected it gives me NaNs

Question is what can be done so that it won't give NaNs and I can still label them?

3 Answers 3

You can set the index directly:

Note: you can also do this with map (which is a little cleaner):

...though I should say that usually this isn't something you usually need to do, keeping integer index is A Good Thing TM .

A list comprehension would also work:

For you to be able to do this on the DataFrame constructor you would need nest dicts, and the indexes are used to extract the values from the nest dict (which is why you got NaN ), e.g.:

But this seems unnecessary when you can reindex after creating as per @AndyHayden post.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python pandas or ask your own question .

• Featured on Meta
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• Announcing a change to the data-dump process

Hot Network Questions

• Who are these Green Lanterns in Justice League: Crisis on Infinite Earths Part 3 animated movie?
• Table saw trips circuit breaker
• US visa for EU residency card holders
• When do you stop research or consider the sunken-cost fallacy
• What are the not-winglet wingtips on the CL-415?
• Making an accessible list or array in Latex
• Fabric bleaching / dying question
• How Does Our Current Understanding of QFT Affect Chemistry and Biology?
• How to insert � (U+FFFD) without getting the error "String contains an invalid utf-8 sequence."
• How to best handle many breadcrumbs with overflow menu
• Structure of the headline "Olympics organizers scramble as furor over woke blasphemy grows."
• Homotopy and Homology groups of two disks glued with twists
• Do finite field point counts remember the singularities of an algebraic variety?
• Do I have legal grounds against a book by an ex which depicts private details of my life, including some false events, without permission?
• What concerns are there with soldering stainless steel cable on electronics?
• How can I handle unavailable papers in a systematic literature review?
• What kind of useless Stack Exchange Site is this?
• Can I remove these truss supports?
• How fast does a quantum torpedo leave the firing ship's launch tube?
• "Man cannot live by bread alone." — Is there any logical explanation why this idiom doesn't have an article before "man"?
• End effect of precognition in a physical fight
• What is a Primordial binary?
• Is it illegal in Australia to add "chocolate or sultanas" to an Anzac biscuit?
• Terminology: A "corollary" to a proof?