• df['series'].index → Returns the index (row labels) of the Series.
• df['series'].name → Returns the name of the Series (if assigned).
• df['series'].dtype → Returns the data type of the Series elements.
• df['series'].dtypes → Alias for dtype (same output).
• df['series'].shape → Returns a tuple (n_rows,) representing dimensions.
• df['series'].ndim → Returns the number of dimensions (1 for Series).
• df['series'].size → Returns the number of elements in the Series.
• df['series'].values → Returns the data as a NumPy array.
• df['series'].array → Returns the underlying PandasArray (extension array).

• df['series'].empty → Returns True if the Series is empty.
• df['series'].hasnans → Returns True if the Series contains any NaN values.

• df['series'].flags → Returns a Flags object with memory/performance settings.
• df['series'].set_flags → Modifies the flags (e.g., copy_on_write).
• df['series'].attrs → Returns a dictionary of custom metadata attributes.

• Most frequently used: index, name, dtype, shape, size, values.
• For missing values: hasnans is useful for quick NaN checks.
• Advanced use cases: flags, set_flags, and attrs are rarely needed in everyday workflows.

• df['series'].at → Fast label-based scalar access (single value, like a dictionary).
• df['series'].iat → Fast integer-position-based scalar access (like at but for positions).
• df['series'].loc → Label-based indexing (slicing, single/multiple values).
• df['series'].iloc → Integer-position-based indexing (slicing, single/multiple values).

• Use at/iat for single values (optimized for speed).
• Use loc/iloc for slices or multiple values.

• df['series'].get(key) → Safe value access (returns None/default if key missing, like dict.get).
• df['series'].item() → Extract the single value from a 1-element Series (raises error if size ≠ 1).
• df['series'].to_numpy() → Convert Series to a NumPy array (preferred over .values in modern Pandas).
• df['series'].array → Returns the underlying Pandas extension array (e.g., IntegerArray, StringArray).

• df['series'].pop(key) → Remove and return a value by label (modifies the Series in-place).
• df['series'].items() → Iterate over (index, value) pairs (like dict.items).
• df['series'].iter() → Alias for .items() (older Pandas versions).
• df['series'].keys() → Alias for .index (returns index labels).

• df['series'].xs(key) → Cross-section (select value by label, similar to .loc but less common).

• Need speed for single values? → at (label) / iat (position).
• Slicing or filtering? → loc (label) / iloc (position).
• Safe access with fallback? → get().
• Convert to NumPy? → to_numpy() (modern) or .values (legacy).
• Iterate? → items() or iter().

• df['series'].add(other) → Addition (+ operator equivalent).
• df['series'].sub(other) → Subtraction ( operator equivalent).
• df['series'].mul(other) → Multiplication ( operator equivalent).
• df['series'].div(other) → Division (/ operator, deprecated, use truediv).
• df['series'].truediv(other) → True division (float division, / operator).
• df['series'].floordiv(other) → Floor division (integer division, // operator).
• df['series'].mod(other) → Modulo/remainder (% operator).
• df['series'].pow(other) → Exponentiation (* operator).

• df['series'].radd(other) → Reverse addition (other + series).
• df['series'].rsub(other) → Reverse subtraction (other - series).
• df['series'].rmul(other) → Reverse multiplication (other * series).
• df['series'].rdiv(other) → Reverse division (other / series, deprecated, use rtruediv).
• df['series'].rtruediv(other) → Reverse true division (other / series).
• df['series'].rfloordiv(other) → Reverse floor division (other // series).
• df['series'].rmod(other) → Reverse modulo (other % series).
• df['series'].rpow(other) → Reverse exponentiation (other ** series).

• df['series'].eq(other) → Equal to (== operator).
• df['series'].ne(other) → Not equal to (!= operator).
• df['series'].lt(other) → Less than (< operator).
• df['series'].le(other) → Less than or equal to (<= operator).
• df['series'].gt(other) → Greater than (> operator).
• df['series'].ge(other) → Greater than or equal to (>= operator).
• df['series'].between(left, right) → Check if values are between left and right(inclusive).

• df['series'].nunique() → Number of unique values.
• df['series'].unique() → Array of unique values.
• df['series'].value_counts() → Counts of each unique value.

• df['series'].idxmax() → Index of first max value.
• df['series'].idxmin() → Index of first min value.

• Use describe() for an instant overview.
• value_counts() is ideal for categorical data.
• idxmax/idxmin return positions, not values.

• df['series'].cumsum() → Cumulative sum
• df['series'].cumprod() → Cumulative product
• df['series'].cummax() → Cumulative maximum
• df['series'].cummin() → Cumulative minimum

• df['series'].rank() → Rank values (with tie-breaking methods)
• df['series'].pct_change() → Percentage change between elements
• df['series'].quantile(q) → Value at quantile q (0-1)

• df['series'].nlargest(n) → Top n largest values
• df['series'].nsmallest(n) → Top n smallest values

• df['series'].rolling(window) → Rolling window calculations (mean, sum, etc.)
• df['series'].expanding() → Expanding window calculations
• df['series'].ewm(span) → Exponentially weighted moving average

Key Notes:

• Cumulative methods (cum*) are useful for running totals/products
• rolling()/expanding()/ewm() return objects for further calculations
• nlargest()/nsmallest() preserve original indices by default

• df['series'].corr(other) → Pearson correlation with another Series (-1 to 1)
• df['series'].cov(other) → Covariance with another Series
• df['series'].autocorr(lag=1) → Autocorrelation at specified lag (for time series)

• df['series'].skew() → Skewness (measure of asymmetry)
• df['series'].kurt() / kurtosis() → Kurtosis (tailedness; alias kurtosis)

• df['series'].prod() → Product of all values
• df['series'].sem() → Standard error of the mean (σ/√n)

• corr()/cov() require equal-length Series
• Positive skew() = right-tailed, negative = left-tailed
• High kurtosis() = heavy tails (leptokurtic)
• autocorr() helps detect periodicity in time series

• df['series'].dropna() → Remove missing values (returns new Series)

• df['series'].fillna(value) → Fill NA with specified value/method
• df['series'].ffill() → Forward fill (alias: pad())
• df['series'].bfill() → Backward fill (alias: backfill())
• df['series'].interpolate() → Fill NA via interpolation

• isna/isnull and notna/notnull are identical (use whichever you prefer)
• ffill/pad propagate last valid observation forward
• bfill/backfill propagate next valid observation backward
• interpolate offers multiple methods (linear, polynomial, etc.)

• df['series'].where(cond, other) → Keep values where cond is True, else replace with other
• (Preserves original where condition is met)
• df['series'].mask(cond, other) → Replace values where cond is True with other
• (Opposite of where - modifies where condition is met)

• df['series'].isin(values) → Check if values exist in list/set (values can be list-like)

• df['series'].all() → Return True if all elements are True/truthy
• df['series'].any() → Return True if any element is True/truthy

• where() vs mask(): Think "keep where" vs "replace where"
• isin() is ideal for filtering against multiple values
• all()/any() ignore NA values by default (use skipna=False to include)

• df['series'].astype(dtype) → Force cast to specified dtype (e.g., 'int', 'float', 'str', 'category')
• df['series'].convert_dtypes() → Convert to best possible nullable dtype (Pandas 1.0+)
• df['series'].infer_objects() → Infer better dtype for object columns (soft conversion)

• df['series'].copy(deep=True) → Create a copy (deep=True for full memory copy)
• df['series'].bool() → Return the bool value (only for single-element boolean Series)

• astype() vs convert_dtypes():
• astype() forces conversion (may lose info)
• convert_dtypes() intelligently chooses nullable dtypes (e.g., Int64 instead of float for missing values)
• Use infer_objects() when dealing with mixed-type object columns
• bool() raises ValueError if Series doesn't have exactly 1 boolean element

1. Prefer convert_dtypes() for modern nullable types
2. Use astype() when you need specific control
3. Always copy() before modifying if you need the original
4. bool() is mainly for scalar boolean extraction

• df['series'].map(arg) → Map values using a dict/Series/function (element-wise)
• df['series'].apply(func) → Apply a function along the Series (element-wise or aggregate)

• df['series'].agg(func) → Aggregate using one or multiple operations (alias: aggregate())
• Common funcs: 'sum', 'mean', 'min', 'max', or custom functions

• df['series'].transform(func) → Return transformed values (same shape as input)
• Differs from agg(): maintains original dimensions

• df['series'].combine(other, func) → Combine with another Series using a function
• df['series'].combine_first(other) → Fill nulls using another Series

Key Differences:

Example Usage:

s1 = pd.Series([1, 2, None])
s2 = pd.Series([10, None, 30])

# Element-wise
s1.map({1: 'a', 2: 'b'})          # → ['a', 'b', None]
s1.apply(lambda x: x*2 if pd.notnull(x) else 0) # → [2, 4, 0]

# Aggregation
s1.agg(['sum', 'mean'])            # → Returns Series with both metrics

# Transformation
s1.transform(lambda x: x - x.mean()) # → Center data

# Combination
s1.combine(s2, max)                # → [10, 2, 30]
s1.combine_first(s2)               # → [1, 2, 30] (fills nulls)

• df['datetime_series'].to_period(freq) → Convert to Period (e.g., 'M' for monthly)
• df['period_series'].to_timestamp() → Convert Period back to Timestamp

• Basic Components:
• .dt.year → Extract year
• .dt.month → Extract month (1-12)
• .dt.day → Extract day (1-31)
• .dt.hour → Extract hour (0-23)
• .dt.minute → Extract minute (0-59)
• .dt.second → Extract second (0-59)
• Advanced Components:
• .dt.dayofweek → Day of week (0=Monday, alias: .weekday)
• .dt.dayofyear → Day of year (1-366)
• .dt.quarter → Quarter (1-4)
• .dt.is_month_end → Bool for month-end dates
• .dt.is_quarter_end → Bool for quarter-end dates
• .dt.is_year_end → Bool for year-end dates

• .dt.total_seconds() → Convert entire duration to seconds

Example Usage:

# Create datetime Series
dates = pd.Series(pd.date_range('2023-01-01', periods=3, freq='M'))

# Access components
dates.dt.month          # → [1, 2, 3]
dates.dt.is_quarter_end # → [False, False, True] (March end)

# Formatting
dates.dt.strftime("%Y-%m") # → ['2023-01', '2023-02', '2023-03']

# Rounding
pd.Series([pd.Timestamp('2023-01-01 14:30:45')]).dt.round('H')
# → 2023-01-01 15:00:00

1. The .dt accessor only works with datetime-like Series
2. For timezone handling, use:
• tz_localize() to assign timezones
• tz_convert() to convert timezones
3. Frequency strings (for rounding/periods):
• 'D' = day, 'M' = month, 'Q' = quarter
• 'H' = hour, 'T'/'min' = minute, 'S' = second

• Extracting month/year for grouping
• Flagging period-end dates
• Creating formatted date strings for reports
• Normalizing timestamps to compare dates without times

• df['text_series'].str.lower() → Convert to lowercase
• df['text_series'].str.upper() → Convert to uppercase
• df['text_series'].str.title() → Convert to title case (first letter capitalized)

• df['text_series'].str.strip() → Remove whitespace from both ends
• df['text_series'].str.replace(old, new) → Replace substring patterns
• df['text_series'].str.repeat(n) → Repeat each string n times

• df['text_series'].str.contains(pattern) → Check for substring/regex matches
• df['text_series'].str.startswith(pattern) → Check starting characters
• df['text_series'].str.endswith(pattern) → Check ending characters
• df['text_series'].str.extract(regex) → Extract regex groups into columns

• df['text_series'].str.split(sep) → Split strings by delimiter
• df['text_series'].str.get(i) → Get element at position i after split
• df['text_series'].str.join(sep) → Join list elements with separator

• df['text_series'].str.len() → Get length of each string
• df['text_series'].str.get_dummies(sep) → Convert delimited strings to dummy variables

• df['cat_series'].cat.codes → Returns integer codes for each category
• df['cat_series'].cat.categories → Returns the index of categories
• df['cat_series'].cat.ordered → Returns True if categories have logical ordering

• df['cat_series'].cat.rename_categories(new_names) → Rename categories
• df['cat_series'].cat.reorder_categories(new_order) → Reorder categories
• df['cat_series'].cat.add_categories(new_cats) → Add new categories
• df['cat_series'].cat.remove_categories(to_remove) → Remove specific categories
• df['cat_series'].cat.remove_unused_categories() → Remove unused categories
• df['cat_series'].cat.set_categories(new_cats) → Set new categories (removes others)

• df['cat_series'].cat.as_ordered() → Set categories to be ordered
• df['cat_series'].cat.as_unordered() → Remove ordering

1. All modification methods return new Series (original remains unchanged)
2. Categories are automatically sorted unless specified otherwise
3. Operations preserve category dtype (unlike string operations)

• Memory optimization for string variables with few unique values
• Maintaining fixed category sets (even when some values are missing)
• Statistical modeling with ordered factors
• Grouping operations with controlled category order

1. Use remove_unused_categories() after filtering
2. Set ordering when categories have logical sequence (e.g., sizes)
3. Predefine categories when you need consistent levels across datasets

• df['sparse_series'].sparse → Main accessor for sparse operations
• df['sparse_series'].sparse.npoints → Count of non-fill-value points
• df['sparse_series'].sparse.density → Ratio of non-fill values (0-1)
• df['sparse_series'].sparse.fill_value → Returns the fill value (default NaN)
• df['sparse_series'].sparse.sp_values → Returns the stored non-fill values as numpy array

• df['sparse_series'].sparse.to_coo() → Convert to scipy.sparse.coo_matrix
• pd.Series.sparse.from_coo(coo_matrix) → Create from scipy.sparse.coo_matrix (class method)

Example Usage:

# Create sparse Series
s = pd.Series([0, 0, 1, 0, 3]).astype('Sparse')

# Access properties
s.sparse.density       # → 0.4 (2 non-zero values out of 5)
s.sparse.npoints       # → 2
s.sparse.fill_value    # → 0

# Convert to COO matrix
coo = s.sparse.to_coo()

# Reconstruct from COO
new_series = pd.Series.sparse.from_coo(coo)

Key Notes:

1. Optimized for data with >90% fill values (typically zeros/NaNs)
2. Automatically converts to dense form during most operations
3. Compatible with scipy.sparse matrices for machine learning

Memory Comparison:

python

dense = pd.Series([0]*1_000_000 + [1])        # ~7.6MB
sparse = dense.astype('Sparse[int]')           # ~0.1MB (98% reduction)

Best Practices:

1. Use for high-dimensional sparse data (e.g., transaction records)
2. Check .density before operations to assess sparsity benefits
3. Convert to dense format for small datasets (overhead outweighs benefits)

• df['series'].to_pickle(path) → Save as Python pickle file (preserves dtypes)
• df['series'].to_csv(path) → Export to CSV (with optional header/index)
• df['series'].to_excel(path) → Write to Excel sheet (requires openpyxl/xlsxwriter)
• df['series'].to_hdf(path, key) → Store in HDF5 file (for large datasets)
• df['series'].to_sql(name, con) → Write to SQL database (requires SQLAlchemy)

• df['series'].to_dict() → Convert to Python dictionary {index: value}
• df['series'].to_frame() → Convert to single-column DataFrame
• df['series'].to_xarray() → Convert to xarray.DataArray (for multidimensional data)

• df['series'].to_json() → Serialize to JSON string/file
• df['series'].to_string() → Render as console-friendly string
• df['series'].to_latex() → Generate LaTeX table format
• df['series'].to_markdown() → Convert to Markdown table

• df['series'].to_clipboard() → Copy to system clipboard (for Excel pasting)