Series creation from lists and dicts in Data Analysis Python - Step-by-Step Execution

Concept Flow - Series creation from lists and dicts

Start with data: list or dict

↓

Choose Series constructor

↓

Pass list or dict to pd.Series()

↓

If list: index auto 0..n-1 or custom

↓

If dict: keys become index, values become data

↓

Series object created

↓

Use Series for analysis or display

Create a Series by passing a list or dict to pd.Series(). Lists get numeric index by default; dict keys become index.

Execution Sample

Data Analysis Python

import pandas as pd

lst = [10, 20, 30]
s = pd.Series(lst)  # Step 1: default index

dct = {'a': 100, 'b': 200}
s2 = pd.Series(dct)  # Step 2: dict keys as index

s = pd.Series(lst, index=[5, 6, 7])  # Step 3: list with custom index

s2 = pd.Series(dct, index=['a', 'b', 'c'])  # Step 4: dict with extra index

Create Series from list (default and custom index) and dict (keys as index and with extra index causing NaN).

Execution Table

Step	Data Type	Input Data	Index Used	Series Data	Action
1	list	[10, 20, 30]	Default 0,1,2	[10, 20, 30]	Create Series from list, index auto assigned
2	dict	{'a': 100, 'b': 200}	Keys 'a', 'b'	[100, 200]	Create Series from dict, keys become index
3	list with custom index	[10, 20, 30]	[5, 6, 7]	[10, 20, 30]	Create Series from list with custom index
4	dict with missing keys	{'a': 100, 'b': 200}	['a', 'b', 'c']	[100, 200, NaN]	Create Series from dict with extra index, missing key gets NaN
5	End				All Series created successfully

💡 All Series objects created; process ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
lst	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
dct	{'a': 100, 'b': 200}	{'a': 100, 'b': 200}	{'a': 100, 'b': 200}	{'a': 100, 'b': 200}	{'a': 100, 'b': 200}	{'a': 100, 'b': 200}
s	null	Series with index 0,1,2 and data [10,20,30]	Same	Series with index 5,6,7 and data [10,20,30]	Same	Same
s2	null	null	Series with index ['a','b'] and data [100,200]	Same	Series with index ['a','b','c'] and data [100,200,NaN]	Same

Key Moments - 3 Insights

Why does a Series created from a dict use the dict keys as the index?

Because pandas treats dict keys as labels for data points, so keys become the Series index automatically (see execution_table step 2).

What happens if you provide a custom index longer than the list when creating a Series?

Pandas raises an error because the index length must match the data length exactly (not shown in table but important to know).

Why does a Series created from a dict with an index containing keys not in the dict show NaN?

Because pandas cannot find data for that index label, so it fills with NaN to indicate missing data (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what index does the Series created from the list [10, 20, 30] get by default?

A [0, 1, 2]

B ['a', 'b', 'c']

C [5, 6, 7]

D ['a', 'b']

💡 Hint

Check execution_table row 1 under 'Index Used' column.

At which step does the Series contain a NaN value due to missing index key?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at execution_table row 4 under 'Series Data' column.

If you create a Series from a dict {'x': 1, 'y': 2} without specifying index, what will be the index?

A [0, 1]

B ['a', 'b']

C ['x', 'y']

D ['x', 'y', 'z']

💡 Hint

Refer to execution_table step 2 where dict keys become index.

Concept Snapshot

pd.Series(data, index=null)
- data: list or dict
- If list: index defaults to 0..n-1
- If dict: keys become index
- Custom index can be provided
- Missing keys in dict with custom index show NaN

Full Transcript

This lesson shows how to create pandas Series from lists and dictionaries. When you pass a list to pd.Series(), pandas assigns a default numeric index starting at 0. When you pass a dictionary, pandas uses the dictionary keys as the index labels. You can also provide a custom index for lists or dicts. If the custom index has labels not in the dict, pandas fills those with NaN. The execution table traces these steps with example data. Key points include understanding how index is assigned and how missing data is handled.

Practice

1. What does a pandas Series store besides the data itself?

easy

A. Multiple columns like a DataFrame

B. Labels (index) for each data element

C. Only numeric values

D. No labels, just raw data

Solution

1. Step 1: Understand what a Series is

   A Series is like a list but with labels for each element.

2. Step 2: Identify what is stored besides data

   Besides the data values, a Series stores labels called an index.

3. Final Answer:

   Labels (index) for each data element -> Option B

4. Quick Check:

   Series stores data + labels [OK]

Hint: Remember: Series = data + labels (index) [OK]

Common Mistakes:

• Thinking Series stores multiple columns like DataFrame
• Assuming Series only stores numeric data
• Believing Series has no labels

2. Which of the following is the correct way to create a pandas Series from a list [10, 20, 30] with labels ['a', 'b', 'c']?

easy

A. pd.Series([10, 20, 30], labels=['a', 'b', 'c'])

B. pd.Series(index=[10, 20, 30], data=['a', 'b', 'c'])

C. pd.Series({'a':10, 'b':20, 'c':30})

D. pd.Series([10, 20, 30], index=['a', 'b', 'c'])

Solution

1. Step 1: Recall Series creation syntax from list

   Use pd.Series(data_list, index=labels_list) to assign labels.

2. Step 2: Check each option

   pd.Series([10, 20, 30], index=['a', 'b', 'c']) uses correct syntax: data first, then index labels. Others misuse parameters or use wrong keywords.

3. Final Answer:

   pd.Series([10, 20, 30], index=['a', 'b', 'c']) -> Option D

4. Quick Check:

   Correct syntax uses index= for labels [OK]

Hint: Use index= to assign labels when creating Series from list [OK]

Common Mistakes:

• Using labels= instead of index=
• Swapping data and index parameters
• Passing dict instead of list for this question

3. What will be the output of this code?

import pandas as pd
s = pd.Series({'x': 5, 'y': 10, 'z': 15})
print(s['y'])

medium

A. 10

B. 'y'

C. KeyError

D. 5

Solution

1. Step 1: Understand Series creation from dict

   Keys become labels, values become data. So 'y' label has value 10.

2. Step 2: Access value by label 'y'

   Using s['y'] returns the value 10 stored at label 'y'.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Dict keys = labels, s['y'] = 10 [OK]

Hint: Dict keys become labels; access by label returns value [OK]

Common Mistakes:

• Expecting s['y'] to return the label 'y'
• Confusing keys and values
• Thinking it raises KeyError

4. Identify the error in this code snippet:

import pandas as pd
s = pd.Series([1, 2, 3], index=['a', 'b'])

medium

A. No error, code runs fine

B. Data must be a dictionary, not a list

C. Index length does not match data length

D. pd.Series cannot take index parameter

Solution

1. Step 1: Check lengths of data and index

   Data has 3 elements, index has 2 labels. They must be equal length.

2. Step 2: Understand pandas behavior

   Mismatch causes ValueError: Length of passed values does not match index.

3. Final Answer:

   Index length does not match data length -> Option C

4. Quick Check:

   Data and index lengths must match [OK]

Hint: Data and index must have same length [OK]

Common Mistakes:

• Assuming list data must be dict
• Thinking index parameter is invalid
• Ignoring length mismatch error

5. You have a dictionary {'a': 1, 'b': 0, 'c': 3, 'd': None}. You want to create a Series that only includes keys with truthy values (non-zero, non-None). Which code correctly creates this filtered Series?

hard

A. pd.Series({k: v for k, v in {'a':1, 'b':0, 'c':3, 'd':None}.items() if v})

B. pd.Series({'a':1, 'b':0, 'c':3, 'd':None}).dropna()

C. pd.Series({'a':1, 'b':0, 'c':3, 'd':None}).fillna(0)

D. pd.Series({'a':1, 'b':0, 'c':3, 'd':None})

Solution

1. Step 1: Understand filtering for truthy values

   Truthy means values that are not 0, None, False, or empty.

2. Step 2: Check each option's effect

   pd.Series({k: v for k, v in {'a':1, 'b':0, 'c':3, 'd':None}.items() if v}) uses dict comprehension to filter out falsy values before creating Series. pd.Series({'a':1, 'b':0, 'c':3, 'd':None}).dropna() only drops None but keeps 0. pd.Series({'a':1, 'b':0, 'c':3, 'd':None}).fillna(0) replaces None with 0, keeping falsy values. pd.Series({'a':1, 'b':0, 'c':3, 'd':None}) includes all values.

3. Final Answer:

   pd.Series({k: v for k, v in {'a':1, 'b':0, 'c':3, 'd':None}.items() if v}) -> Option A

4. Quick Check:

   Filter dict first to exclude falsy values [OK]

Hint: Filter dict with if v before Series creation [OK]

Common Mistakes:

• Using dropna() only removes None, not 0
• Filling None with 0 keeps falsy values
• Not filtering before creating Series