{"id":"l-pda-2-3","courseId":"python-data-analysis","lang":"en","kind":"lesson","summary":"Select columns with square brackets, then pick exact rows and columns with .loc (by label) and .iloc (by position), and know which one to use after sorting or filtering.","html":"

Cartwheel’s product manager asks: “What do we charge for the coffee grinder, product 7?” and “Show me the five priciest products with their costs.” Both are selection problems: out of a table, get exactly these rows and these columns. pandas gives you two precise tools for that, .loc and .iloc, and most beginner confusion comes from mixing them up. The rule is short: .loc uses labels, .iloc uses positions.

\n

Columns first

\n

Square brackets on a DataFrame select columns:

\n
Python
import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\nprint(products[\"name\"].head(3))                    # one column: a Series\nprint(products[[\"name\", \"unit_price\"]].head(3))    # a list of columns: a DataFrame
\n

index_col="product_id" made the product id the row index instead of the default 0, 1, 2. That single choice makes everything below read naturally: product 7 is the row labelled 7. On an already-loaded DataFrame, products.set_index("product_id") does the same thing and returns a new DataFrame.

\n

You will also see products.unit_price in tutorials. Dot access works for simple names, but it fails for names with spaces, and it quietly returns the wrong thing when a column shares its name with a DataFrame method: a column called count or size is shadowed by the method of the same name. Square brackets always work, so make them your default.

\n

The double brackets are not a typo. The outer pair is the selection; the inner pair is a Python list of column names. One column in a list still gives a DataFrame.

\n

.loc: select by label

\n

.loc[rows, columns] takes row labels first, then column labels:

\n
Python
import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\nprint(products.loc[7, \"unit_price\"])                       # one value\nprint(products.loc[7])                                     # one row, as a Series\nprint(products.loc[[11, 21, 37], [\"name\", \"unit_price\"]])  # chosen rows and columns\nprint(products.loc[1:3, \"name\":\"unit_price\"])              # label slices
\n

Lists pick exactly the labels you name, in that order. Slices take a range of labels, and here is the part to remember: .loc slices include the end label. products.loc[1:3] returns products 1, 2 and 3. The column slice "name":"unit_price" likewise includes unit_price. It makes sense once you think in labels: “from product 1 to product 3” includes product 3.

\n

Ask for a label that does not exist, say products.loc[99], and you get KeyError: 99. That is a feature: a wrong id should fail loudly, not return an empty result you might paste into a report. When a missing label is a normal possibility, test first with 99 in products.index, which returns True or False.

\n

.loc is also the one tool you use for assigning values, as you will see in Lesson 2.5: products.loc[7, "unit_price"] = 135.45 changes exactly one cell.

\n

.iloc: select by position

\n

.iloc ignores labels and counts positions from 0, with slices that exclude the end, exactly like Python lists:

\n
Python
import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\nprint(products.iloc[0])            # first row, whatever its label\nprint(products.iloc[:3, :2])       # first three rows, first two columns\nprint(products.iloc[-1][\"name\"])   # last row's name
\n

Use .iloc when position is what you mean: “the first five”, “the last row”, “every other row”. Use .loc when identity is what you mean: “product 7”, “the unit_price column”.

\n
\n A table sorted by price with index labels 21, 22, 41, 1 in that order and positions 0 to 3. loc[1] points to the row labelled 1, which sits at position 3. iloc[0] points to the row at position 0, which is labelled 21.\n position\n label\n name (sorted by price)\n \n 0\n 21\n Standing Desk 140cm\n \n 1\n 22\n Ergonomic Task Chair\n \n 2\n 41\n Adjustable Dumbbells\n \n ...\n 1\n Cast Iron Skillet 26cm\n .iloc[0]\n \n .loc[1]\n \n
.loc finds rows by label, .iloc by position
\n

Why the difference matters: sorting

\n

Sort the products by price and the two tools part ways:

\n
Python
import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\nby_price = products.sort_values(\"unit_price\", ascending=False)\nprint(by_price.iloc[:3][[\"name\", \"unit_price\"]])   # the three priciest\nprint(by_price.loc[1, \"name\"])                     # still the skillet
\n

Sorting moves rows but each row keeps its label. by_price.iloc[0] is now the Standing Desk, the most expensive item at 449 dollars; by_price.loc[1] is still the Cast Iron Skillet, wherever it ended up. Filtering behaves the same way: after you keep only some rows, labels have gaps (1, 4, 9…), and positions are renumbered 0, 1, 2. If you ever want fresh 0-to-n labels, reset_index(drop=True) gives them back.

\n\n\n

In the exercise you answer the product manager’s questions with .loc and .iloc. Next you select rows by a condition instead of by label: “all orders over 200 dollars”, “all web orders in November”.

\n","toc":[{"id":"sec-1","text":"Columns first","level":2},{"id":"sec-2","text":".loc: select by label","level":2},{"id":"sec-3","text":".iloc: select by position","level":2},{"id":"sec-4","text":"Why the difference matters: sorting","level":2}],"takeaways":["df["col"] returns one column as a Series; df[["a", "b"]] (a list inside the brackets) returns a DataFrame.",".loc[rows, columns] selects by label, and its slices include the end label.",".iloc[rows, columns] selects by position, and its slices exclude the end, like Python lists.","After sorting, labels stay attached to their rows, so .loc still finds the same product while .iloc[0] finds whatever is now first.","Set a meaningful index such as product_id with index_col= or set_index() so .loc reads like a lookup."],"further":[{"title":"Indexing and selecting data","url":"https://pandas.pydata.org/docs/user_guide/indexing.html"},{"title":"pandas.DataFrame.loc","url":"https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html"},{"title":"pandas.DataFrame.iloc","url":"https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html"}],"quiz":[{"q":"

products is indexed by product_id (1 to 48). How many rows does products.loc[1:5] return?

","options":[{"text":"4","why":"That would be a positional slice that excludes the end. .loc slices by label and includes it."},{"text":"6","why":"Labels 1, 2, 3, 4 and 5 are five rows; nothing in this slice reaches a sixth."},{"text":"An error, because 1:5 are positions","why":"With an integer index, .loc treats the numbers as labels, and these labels exist."},{"text":"5","why":"Correct. .loc slices include both ends, so labels 1 through 5 come back."}],"answer":3},{"q":"

You sort products by price, highest first. Which expression returns the most expensive product’s row?

","options":[{"text":"by_price.loc[1]","why":".loc[1] is the row labelled 1, the Cast Iron Skillet, wherever it now sits."},{"text":"by_price[0]","why":"Square brackets with a single value look for a column named 0, which raises KeyError."},{"text":"by_price.iloc[1]","why":"Positions start at 0, so this is the second most expensive product."},{"text":"by_price.iloc[0]","why":"Correct. After sorting, position 0 holds the most expensive product, whatever its label."}],"answer":3},{"q":"

What does products[["name"]] return, compared to products["name"]?

","options":[{"text":"Exactly the same Series.","why":"The double brackets pass a list of columns, which always returns a DataFrame, even for one column."},{"text":"A one-column DataFrame instead of a Series.","why":"Correct. A list inside the brackets means “these columns, as a table”. Some functions need a DataFrame, others a Series, so the difference matters."},{"text":"The column’s name as a string.","why":"Both forms return data, not the label. products.columns lists the names."}],"answer":1},{"q":"

Which line gets the unit price of product 7 in a single, unambiguous step?

","options":[{"text":"products.loc[7, "unit_price"]","why":"Correct. One .loc call with a row label and a column label selects exactly one value."},{"text":"products.iloc[7, "unit_price"]","why":".iloc accepts positions only; a column name raises an error, and position 7 is product 8 anyway."},{"text":"products["unit_price"][7]","why":"It happens to work for reading, but it is two selection steps; the same pattern used for assignment is the chained assignment that breaks under Copy-on-Write."}],"answer":0}],"exercise":{"kind":"python","files":["products.csv"],"starter":"import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\n\n# 1. Unit price of product 7 (a single number)\ngrinder_price = None\n\n# 2. Rows for products 11, 21 and 37, with only the name and unit_cost columns\nsubset = None\n\n# 3. The five most expensive products (all columns), most expensive first\ntop5 = None\n\n# 4. The name of the cheapest product\ncheapest_name = None\n","solution":"import pandas as pd\n\nproducts = pd.read_csv(\"products.csv\", index_col=\"product_id\")\n\ngrinder_price = products.loc[7, \"unit_price\"]\n\nsubset = products.loc[[11, 21, 37], [\"name\", \"unit_cost\"]]\n\nby_price = products.sort_values(\"unit_price\", ascending=False)\ntop5 = by_price.iloc[:5]\n\ncheapest_name = by_price.iloc[-1][\"name\"]\n","checks":[{"id":"grinder","test":"float(grinder_price) == 129.0"},{"id":"subset","test":"isinstance(subset, pd.DataFrame) and list(subset.index) == [11, 21, 37] and list(subset.columns) == ['name', 'unit_cost']"},{"id":"top5","test":"isinstance(top5, pd.DataFrame) and len(top5) == 5 and list(top5['unit_price']) == [449, 329, 289, 199, 189]"},{"id":"top5-columns","test":"'name' in top5.columns and 'unit_cost' in top5.columns"},{"id":"cheapest","test":"cheapest_name == 'Jump Rope Pro'"}],"title":"Answer the product manager","prompt":"

products is loaded with product_id as its index. Set grinder_price to the unit price of product 7. Set subset to products 11, 21 and 37 with only the name and unit_cost columns, in that order. Set top5 to the five most expensive products with all their columns, most expensive first. Set cheapest_name to the name of the cheapest product.

\n","hints":["Product 7 is a label, so use .loc[7, "unit_price"].",".loc takes a list of row labels and a list of column names: .loc[[11, 21, 37], ["name", "unit_cost"]].","Sort with products.sort_values("unit_price", ascending=False), then take positions with .iloc[:5]. The cheapest product is at position -1 of that sorted table (or position 0 of an ascending sort)."],"explanation":"

Product ids are labels, so .loc is the right tool for questions 1 and 2, and it returns the columns in the order you list them. “The five most expensive” is about position after sorting, so .iloc[:5] on the sorted table is the natural fit; nlargest(5, "unit_price"), which you meet next lesson, also works. The cheapest product is the Jump Rope Pro at 18 dollars. Notice that .loc[1:5] on the sorted table would not give the top five: it would return whatever rows sit between labels 1 and 5 in their new positions, which has nothing to do with price.

\n","checkLabels":{"grinder":"grinder_price is 129","subset":"subset has products 11, 21, 37 and the columns name, unit_cost","top5":"top5 holds the five highest prices in descending order","top5-columns":"top5 keeps all the columns","cheapest":"cheapest_name is Jump Rope Pro"}},"words":684,"readMinutes":3}