DataFrame Anatomy & Attributes

Before analysing any dataset, you should be able to answer: How many rows and columns? What are the column names? What type is each column? What are the row labels? DataFrame attributes answer all of these instantly. They also teach you the vocabulary — index, columns, axis 0, axis 1 — that every pandas method uses.

We will use this IPL 2023 top run-scorers table throughout (sample data):

             player team  matches  runs  strike_rate
0      Shubman Gill   GT       17   890        157.8
1    Faf du Plessis  RCB       14   730        153.7
2      Devon Conway  CSK       16   672        139.7
3       Virat Kohli  RCB       14   639        139.8
4  Yashasvi Jaiswal   RR       14   625        163.6
5  Suryakumar Yadav   MI       16   605        181.1
6   Ruturaj Gaikwad  CSK       16   590        147.5
7       Rinku Singh  KKR       14   474        149.5

Definition

The anatomy of a DataFrame has three parts: the index (row labels, along axis 0), the columns (column labels, along axis 1), and the values (the 2D grid of data). Attributes such as shape, dtypes and columns describe these parts without changing them.

                    columns  (axis 1  →)
              ┌──────────────────────────────────────────┐
              │  player        team  matches  runs  ...   │
   index  ┌───┼──────────────────────────────────────────┤
  (axis 0 │ 0 │  Shubman Gill  GT    17       890         │
     ↓)   │ 1 │  Faf du Plessis RCB  14       730   values │
          │ 2 │  Devon Conway  CSK   16       672         │
          └───┴──────────────────────────────────────────┘

• axis 0 = rows (down), axis 1 = columns (across) — the same convention as NumPy. Methods like drop, sum and mean take axis= to say which way to work.
• Index — the row labels. A default index is a memory-efficient RangeIndex.
• Columns — also an Index object, holding the column names.

Syntax

Example — shape, size, ndim, index and columns

print(df.index)
print(df.columns)
print(df.shape)
print(df.size)
print(df.ndim)
print(len(df))

RangeIndex(start=0, stop=8, step=1)
Index(['player', 'team', 'matches', 'runs', 'strike_rate'], dtype='str')
(8, 5)
40
2
8

How it works: shape is (8, 5) → 8 rows, 5 columns; use df.shape[0] for the row count and df.shape[1] for the column count. size = 8 × 5 = 40 cells. The index is a RangeIndex from 0 up to (not including) 8. Column names are stored in an Index with dtype str. Use df.columns.tolist() to get a plain list.

Example — dtypes

print(df.dtypes)

player             str
team               str
matches          int64
runs             int64
strike_rate    float64
dtype: object

How it works: dtypes returns a Series — index = column names, values = their dtypes. (The footer dtype: object is the dtype of that Series of dtypes; ignore it.) This is the first place to look when maths on a column fails — numbers stored as str cannot be summed.

Note (pandas 3): text columns show as str. Older tutorials show object for the same data.

Example — values / to_numpy and axes

print(df[["matches", "runs"]].to_numpy())
print(df.to_numpy()[:2])
print(df.axes)

[[ 17 890]
 [ 14 730]
 [ 16 672]
 [ 14 639]
 [ 14 625]
 [ 16 605]
 [ 16 590]
 [ 14 474]]
[['Shubman Gill' 'GT' 17 890 157.8]
 ['Faf du Plessis' 'RCB' 14 730 153.7]]
[RangeIndex(start=0, stop=8, step=1), Index(['player', 'team', 'matches', 'runs', 'strike_rate'], dtype='str')]

How it works: to_numpy() drops the labels and returns the raw 2D array. For two integer columns the array is int64. For the whole table — text and numbers mixed — NumPy needs one common type, so the array becomes object (generic Python objects). That is why machine-learning code usually selects numeric columns first. df.values does the same thing, but to_numpy() is the recommended, explicit name.

Example — transpose

print(df.T.iloc[:, :3])

                        0               1             2
player       Shubman Gill  Faf du Plessis  Devon Conway
team                   GT             RCB           CSK
matches                17              14            16
runs                  890             730           672
strike_rate         157.8           153.7         139.7

df.T swaps rows and columns — handy for reading one wide record vertically.

Comparison — Series vs DataFrame attributes

Common mistakes

• ❌ df.shape() → TypeError: 'tuple' object is not callable. ✅ df.shape (no parentheses).
• ❌ df.dtype → AttributeError. ✅ df.dtypes (plural) for a DataFrame.
• ❌ Using df.size to count rows. ✅ len(df) or df.shape[0]; size counts cells.
• ❌ Expecting df.to_numpy() on a mixed table to be numeric. ✅ Select numeric columns first (df.select_dtypes("number").to_numpy()).

Interview tip

Q: What is the difference between len(df), df.shape and df.size? A: len(df) is the number of rows; df.shape is the tuple (rows, columns); df.size is the total number of cells, rows × columns, including missing values.