5 Best Ways to Create a Time Series Plot with Multiple Columns Using Line Plot in Python

💡 Problem Formulation: Creating a time-series plot is essential for analyzing trends and patterns over time. In Python, users often have multi-column datasets where each column represents a different variable over time. The task is to visualize these variables together on a single line plot for better comparison and analysis. For instance, we would take input in the form of a pandas DataFrame with date-time indices and plot multiple columns as separate lines on a single graph.

Method 1: Matplotlib

Matplotlib is a fundamental plotting library in Python’s data visualization stack. It offers extensive customization capabilities to create time series line plots. To plot multiple columns, one can iterate over DataFrame columns and add each as a separate line to the Matplotlib figure.

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

This extremely concise code snippet leverages the inline plotting functionality of Jupyter Notebooks to render a simple time series plot directly in the output cell, using the DataFrame’s plot() method with a specified figure size.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Plotly Express is utilized in this example to create the plot. The code calls the px.line() function, specifying the DataFrame index as the x-axis and all DataFrame columns for the y-axis. The resulting plot is interactive and can be used for more in-depth data exploration.

Bonus One-Liner Method 5: Quick Pandas Plot

For a rapid and straightforward time series plot using pandas, one can utilize the inline plot capability directly in a Jupyter Notebook. This one-liner method is extremely efficient for quick exploratory data analysis.

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

By using Seaborn’s lineplot() function, this code first “melts” the DataFrame to have a long-form representation where the variable names are stored in a single column. It then plots these values, using the ‘measurement’ column to specify line color and style with the ‘hue’ parameter.

Method 4: Plotly

Plotly offers interactive plotting capabilities for Python. It provides a straightforward and flexible API for creating time series plots with multiple columns through its graph objects or express interfaces. The plots are interactive, allowing users to hover over data points to see precise values.

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

This code uses pandas’ built-in plot() method to create a line plot for each numeric column in the DataFrame. This method is quicker than Matplotlib since it infers the x-axis from the index and automatically creates a line for each remaining column.

Method 3: Seaborn

Seaborn is a statistical data visualization library built on top of Matplotlib that offers a higher-level interface and attractive default styles. It works well with pandas DataFrames and can create a multi-line time series plot through the use of its lineplot() function with a ‘hue’ parameter for distinguishing different columns.

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

This code snippet creates a pandas DataFrame from a dictionary, sets the ‘date’ column as the index, and then iterates over the remaining columns. Each column is plotted as a separate line with plt.plot(), and plt.legend() is called to display the legend.

Method 2: Pandas Plot

pandas provides a high-level plot() method built on Matplotlib. With a datetime index already set, calling plot() on a DataFrame will create a line plot for all numeric columns. This method is more concise and integrates smoothly with pandas DataFrames.

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
plt.figure(figsize=(10,5))
for column in df.columns:
    plt.plot(df.index, df[column], label=column)

plt.legend()
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days.

Method 2: Pandas Plot

Here’s an example:

import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
df.plot(figsize=(10,5))
plt.show()

Output: A line plot displaying ‘temp’ and ‘humidity’ trends over seven days, similar to the Matplotlib plot.

Method 3: Seaborn

Here’s an example:

import seaborn as sns
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data)
df = df.melt('date', var_name='measurement', value_name='value')

# Plotting
sns.lineplot(data=df, x='date', y='value', hue='measurement')
plt.show()

Output: A stylized line plot showing ‘temp’ and ‘humidity’ trends with distinct colors for each measurement type.

Method 4: Plotly

Here’s an example:

import plotly.express as px
import pandas as pd
from datetime import datetime

# Sample data
data = {
    'date': [datetime(2021, 1, i) for i in range(1, 8)],
    'temp': [30, 35, 28, 33, 31, 34, 36],
    'humidity': [45, 50, 55, 48, 58, 60, 61]
}

df = pd.DataFrame(data).set_index('date')

# Plotting
fig = px.line(df, x=df.index, y=df.columns)
fig.show()

Output: An interactive line plot that allows users to engage with the data points and view information about ‘temp’ and ‘humidity’ over the span of seven days.

Bonus One-Liner Method 5: Quick Pandas Plot

Here’s an example:

df.plot(figsize=(10,5))  # Assuming 'df' is a pandas DataFrame with a datetime index and columns to be plotted.

Output: A quick line plot displayed inline within a Jupyter Notebook.

Summary/Discussion

Method 1: Matplotlib. Offers extensive customization and control. May require more lines of code for plots involving larger datasets.
Method 2: Pandas Plot. Quick and integrated with pandas. Less customizable than Matplotlib for complex plots.
Method 3: Seaborn. Provides attractive default plotting styles and works well with long-form data. Potentially less intuitive for data in wide-form format.
Method 4: Plotly. Interactive and user-friendly plots, best for web applications and presentations. Larger data sets might result in slower performance.
Bonus One-Liner Method 5: Quick Pandas Plot. Fastest for inline plotting within Jupyter Notebooks, lacks customization and interactivity of standalone plots.