Python Pandas Tutorial (Part 2): DataFrame and Series Basics - Selecting Rows and Columns

Pandas’ core data structures—DataFrame (2D) and Series (1D)—become much easier to work with once they’re treated like rows/columns containers rather than “mysterious pandas objects.” A DataFrame behaves like a table: each row is one record (in the example, one survey respondent), and each column is a field (each survey question). A Series behaves like a single column: when one column is pulled from a DataFrame, the result is a Series with its own index and additional methods.

The tutorial starts by grounding DataFrames in a real dataset setup: survey results are loaded into a main DataFrame (DF) and a separate schema DataFrame describes what each question/column means. Using DF.head() reveals the table structure—multiple rows and multiple columns—while the schema DataFrame clarifies column semantics (for instance, identifying what “hobbyist” corresponds to in the questionnaire). This framing matters because it explains why selecting data in pandas feels like slicing a table: columns are fields, rows are records.

To build intuition, the lesson contrasts pandas with plain Python dictionaries. A dictionary of lists can represent multiple records: keys act like column names (e.g., first, last, email), and each list element corresponds to a row. Creating a DataFrame from that dictionary (PD.DataFrame) produces a tabular view with an index on the left (initially 0, 1, 2, …). When a single column is accessed (DF['email']), pandas returns a Series, not a raw list—confirmed by checking the object type. The Series is described as “rows of a single column,” and the DataFrame is presented as a container holding multiple Series objects.

From there, the tutorial moves into practical selection patterns. Single-column selection uses bracket notation (DF['column']), while dot notation (DF.column) is shown as an alternative but discouraged as a preference because column names can collide with DataFrame methods (e.g., a column named count could conflict with a count method). Selecting multiple columns requires an inner list (DF[['last', 'email']]); otherwise pandas may treat the strings incorrectly. The lesson also shows how to list all columns via DF.columns.

Row selection introduces two indexers: .iloc for integer-location access and .loc for label-based access. .iloc uses positional integers (DF.iloc[0] for the first row), and can select multiple rows with a list of integers. .loc uses index labels (DF.loc[0] for the row labeled 0) and supports selecting columns by name alongside row labels. Both indexers can combine row and column selection, returning either a Series (single column) or a smaller DataFrame (multiple columns).

Finally, the tutorial applies these ideas to the Stack Overflow survey dataset. It uses DF.shape to confirm scale (88,000 rows and 85 columns), selects the entire “hobbyist” column (DF['hobbyist']), and demonstrates value_counts() to count “yes” vs “no” responses. It then selects a specific respondent row with DF.loc[0, 'hobbyist']-style logic, pulls multiple rows for that column, and uses slicing to grab ranges of rows and columns—highlighting that .loc slicing is inclusive on the end label (so hobbyist through employment includes the employment column). The takeaway is that once DataFrame/Series mental models and the .loc/.iloc rules are clear, extracting exactly the rows and columns needed becomes straightforward and powerful.