pandas

https://pandas.pydata.org/docs
Admin
pandas is an open source, BSD-licensed library providing high-performance, easy-to-use data...
Tokens:3,238,939
Snippets:26,641
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Setup for groupby as_index=False example

Source: https://pandas.pydata.org/docs/whatsnew/v0.15.1.html

Sets up a DataFrame and a Series for the groupby example.

```python
In [5]: np.random.seed(2718281)

In [6]: df = pd.DataFrame(np.random.randint(0, 100, (10, 2)), columns=["jim", "joe"])

In [7]: df.head()
Out[7]: 
   jim  joe
0   61   81
1   96   49
2   55   65
3   72   51
4   77   12

[5 rows x 2 columns]

In [8]: ts = pd.Series(5 * np.random.randint(0, 3, 10))

```

--------------------------------

### Implicit imports for all examples

Source: https://pandas.pydata.org/docs/development/contributing_docstring.html

These two lines are assumed to be present at the start of every example in the documentation, though they are not shown in the examples themselves.

```python
import numpy as np
import pandas as pd

```

--------------------------------

### Create sample DataFrame for indexing examples

Source: https://pandas.pydata.org/docs/whatsnew/v0.20.0.html

Creates a sample DataFrame with a label index and displays it. This is the setup used by the subsequent .ix, .loc, and .iloc examples.

```python
In [101]: df = pd.DataFrame({'A': [1, 2, 3],
   .....:                    'B': [4, 5, 6]},
   .....:                   index=list('abc'))
   .....: 

In [102]: df
Out[102]: 
   A  B
a  1  4
b  2  5
c  3  6

[3 rows x 2 columns]

```

--------------------------------

### Create sample DataFrame for eval examples

Source: https://pandas.pydata.org/docs/whatsnew/v0.18.0.html

Creates a sample DataFrame with columns 'a' and 'b' and displays it. This is the starting point for the eval examples that follow.

```python
In [86]: df = pd.DataFrame({'a': np.linspace(0, 10, 5), 'b': range(5)})

In [87]: df
Out[87]: 
      a  b
0   0.0  0
1   2.5  1
2   5.0  2
3   7.5  3
4  10.0  4

[5 rows x 2 columns]
```

--------------------------------

### Setup for groupby column name conflict example

Source: https://pandas.pydata.org/docs/whatsnew/v0.15.1.html

Sets up a DataFrame and a groupby object for the column name conflict example.

```python
In [9]: df = pd.DataFrame({"jim": range(5), "joe": range(5, 10)})

In [10]: df
Out[10]: 
   jim  joe
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9

[5 rows x 2 columns]

In [11]: gr = df.groupby(df["jim"] < 2)

```

--------------------------------

### Setup for groupby nth filtration example

Source: https://pandas.pydata.org/docs/whatsnew/v2.0.0.html

Creates a DataFrame and groupby object used in the nth examples.

```python
In [21]: df = pd.DataFrame({"a": [1, 1, 2, 1, 2], "b": [np.nan, 2.0, 3.0, 4.0, 5.0]})

In [22]: gb = df.groupby("a")
```

--------------------------------

### Setup for .loc slicing examples

Source: https://pandas.pydata.org/docs/whatsnew/v0.16.0.html

Creates a DataFrame and Series used in the .loc slicing examples. The DataFrame has a DatetimeIndex and the Series has an integer index.

```python
In [23]: df = pd.DataFrame(np.random.randn(5, 4),
   ....:                   columns=list('ABCD'),
   ....:                   index=pd.date_range('20130101', periods=5))
   ....: 

In [24]: df
Out[24]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-05 -0.424972  0.567020  0.276232 -1.087401

[5 rows x 4 columns]

In [25]: s = pd.Series(range(5), [-2, -1, 1, 2, 3])

In [26]: s
Out[26]: 
-2    0
-1    1
 1    2
 2    3
 3    4
Length: 5, dtype: int64
```

--------------------------------

### Resampler.size example

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.size.html

Shows how to compute group sizes for a Resampler object. The example creates a Series with a DatetimeIndex and resamples by month start, returning a Series with the count of values in each month.

```python
>>> ser = pd.Series(
...     [1, 2, 3],
...     index=pd.DatetimeIndex(["2023-01-01", "2023-01-15", "2023-02-01"]),
... )
>>> ser
2023-01-01    1
2023-01-15    2
2023-02-01    3
dtype: int64
>>> ser.resample("MS").size()
2023-01-01    2
2023-02-01    1
Freq: MS, dtype: int64
```

--------------------------------

### Get start and end timestamps of a Period

Source: https://pandas.pydata.org/docs/reference/api/pandas.Period.start_time.html

These examples create a daily period and show the start and end timestamps. The first block creates a Period object with frequency 'D'. The second and third blocks display the start and end timestamps, respectively.

```python
>>> period = pd.Period('2012-1-1', freq='D')
>>> period
Period('2012-01-01', 'D')

```

```python
>>> period.start_time
Timestamp('2012-01-01 00:00:00')

```

```python
>>> period.end_time
Timestamp('2012-01-01 23:59:59.999999')

```

--------------------------------

### Create sample DataFrame for head() examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.head.html

Creates a sample DataFrame with an 'animal' column containing nine animal names, then displays the full DataFrame. This setup is used by the subsequent examples of DataFrame.head().

```python
>>> df = pd.DataFrame(
...     {
...         "animal": [
...             "alligator",
...             "bee",
...             "falcon",
...             "lion",
...             "monkey",
...             "parrot",
...             "shark",
...             "whale",
...             "zebra",
...         ]
...     }
... )
>>> df
      animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey
5     parrot
6      shark
7      whale
8      zebra
```

--------------------------------

### QuarterBegin offset example

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.QuarterBegin.html

Shows how to add a QuarterBegin offset to a pandas Timestamp, resulting in the next quarter start date. The example creates a Timestamp for January 1, 2022, and adds the offset to get March 1, 2022.

```python
>>> ts = pd.Timestamp(2022, 1, 1)
>>> ts + pd.offsets.QuarterBegin()
Timestamp('2022-03-01 00:00:00')
```

--------------------------------

### Resampler.ohlc() example

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.ohlc.html

Shows how to compute OHLC values for a Resampler. The example creates a Series with a DatetimeIndex and resamples by month start ("MS"), then calls .ohlc() to get open, high, low, and close per period.

```python
>>> ser = pd.Series(
...     [1, 3, 2, 4, 3, 5],
...     index=pd.DatetimeIndex(
...         [
...             "2023-01-01",
...             "2023-01-10",
...             "2023-01-15",
...             "2023-02-01",
...             "2023-02-10",
...             "2023-02-15",
...         ]
...     ),
... )
>>> ser.resample("MS").ohlc()
            open  high  low  close
2023-01-01     1     3    1      2
2023-02-01     4     5    3      5
```

--------------------------------

### Create sample DataFrame for pivot_table()

Source: https://pandas.pydata.org/docs/whatsnew/v0.20.0.html

Creates a sample DataFrame with three columns and displays it. This is the setup used in the pivot_table() examples that follow.

```python
In [98]: df = pd.DataFrame({'col1': [3, 4, 5],
   ....:                    'col2': ['C', 'D', 'E'],
   ....:                    'col3': [1, 3, 9]})
   ....: 

In [99]: df
Out[99]: 
   col1 col2  col3
0     3    C     1
1     4    D     3
2     5    E     9

[3 rows x 3 columns]

```

--------------------------------

### Create a DataFrame with datetime index

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.get.html

Creates a pandas DataFrame with columns for temperature and windspeed, using a date range as the index. This is the setup for the subsequent get() examples.

```python
>>> df = pd.DataFrame(
...     [
...         [24.3, 75.7, "high"],
...         [31, 87.8, "high"],
...         [22, 71.6, "medium"],
...         [35, 95, "medium"],
...     ],
...     columns=["temp_celsius", "temp_fahrenheit", "windspeed"],
...     index=pd.date_range(start="2014-02-12", end="2014-02-15", freq="D"),
... )
```

--------------------------------

### Create DataFrame and groupby for take examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.take.html

Sets up a DataFrame with animal data and a groupby object using a list of group labels. This is the prerequisite for the subsequent take() examples.

```python
>>> df = pd.DataFrame(
...     [
...         ("falcon", "bird", 389.0),
...         ("parrot", "bird", 24.0),
...         ("lion", "mammal", 80.5),
...         ("monkey", "mammal", np.nan),
...         ("rabbit", "mammal", 15.0),
...     ],
...     columns=["name", "class", "max_speed"],
...     index=[4, 3, 2, 1, 0],
... )
>>> df
     name   class  max_speed
4  falcon    bird      389.0
3  parrot    bird       24.0
2    lion  mammal       80.5
1  monkey  mammal        NaN
0  rabbit  mammal       15.0
>>> gb = df.groupby([1, 1, 2, 2, 2])

```

--------------------------------

### Resampler median example

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.median.html

Shows how to compute the median of resampled groups using a Resampler object. The example creates a Series with a DatetimeIndex and resamples by month start ("MS"), then calls median() to get the median per month.

```python
>>> ser = pd.Series(
...     [1, 2, 3, 3, 4, 5],
...     index=pd.DatetimeIndex(
...         [
...             "2023-01-01",
...             "2023-01-10",
...             "2023-01-15",
...             "2023-02-01",
...             "2023-02-10",
...             "2023-02-15",
...         ]
...     ),
... )
>>> ser.resample("MS").median()
2023-01-01    2.0
2023-02-01    4.0
Freq: MS, dtype: float64
```

--------------------------------

### Normalize to midnight with BusinessDay(normalize=True)

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BusinessDay.html

Demonstrates the normalize parameter, which shifts the start of the next business day to midnight. The example adds BusinessDay(normalize=True) to a Friday timestamp and gets Monday, December 12, 2022 at 00:00:00.

```python
>>> ts = pd.Timestamp(2022, 12, 9, 15)
>>> ts + pd.offsets.BusinessDay(normalize=True)
Timestamp('2022-12-12 00:00:00')
```

--------------------------------

### Create a DataFrame for at examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.at.html

Creates a sample DataFrame with index [4, 5, 6] and columns ['A', 'B', 'C'] used in the subsequent at examples.

```python
>>> df = pd.DataFrame(
...     [[0, 2, 3], [0, 4, 1], [10, 20, 30]],
...     index=[4, 5, 6],
...     columns=["A", "B", "C"],
... )
>>> df
    A   B   C
4   0   2   3
5   0   4   1
6  10  20  30
```

--------------------------------

### Create example DataFrames for DataFrame.join

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.join.html

Creates the example DataFrames df and other used throughout the join examples. The first block defines df with columns key and A; the second shows its contents. The third defines other with columns key and B; the fourth shows its contents.

```python
>>> df = pd.DataFrame(
...     {
...         "key": ["K0", "K1", "K2", "K3", "K4", "K5"],
...         "A": ["A0", "A1", "A2", "A3", "A4", "A5"],
...     }
... )

```

```python
>>> df
  key   A
0  K0  A0
1  K1  A1
2  K2  A2
3  K3  A3
4  K4  A4
5  K5  A5

```

```python
>>> other = pd.DataFrame({"key": ["K0", "K1", "K2"], "B": ["B0", "B1", "B2"]})

```

```python
>>> other
  key   B
0  K0  B0
1  K1  B1
2  K2  B2

```

--------------------------------

### Get start time of period

Source: https://pandas.pydata.org/docs/reference/api/pandas.PeriodIndex.start_time.html

Accesses the start_time property to get the Timestamp for the start of the period. The output shows the resulting Timestamp.

```python
>>> period.start_time
Timestamp('2012-01-01 00:00:00')
```

--------------------------------

### Display the example DataFrame

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.idxmin.html

Shows the resulting DataFrame from the previous creation step.

```python
>>> df
                consumption  co2_emissions food_type
Pork                  10.51         37.20       meat
Wheat Products       103.11         19.66      plant
Beef                  55.48       1712.00       meat
```

--------------------------------

### Create sample DataFrame for set_index examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.set_index.html

Creates a DataFrame with columns 'month', 'year', and 'sale' used in the subsequent set_index examples.

```python
>>> df = pd.DataFrame(
...     {
...         "month": [1, 4, 7, 10],
...         "year": [2012, 2014, 2013, 2014],
...         "sale": [55, 40, 84, 31],
...     }
... )
>>> df
   month  year  sale
0      1  2012    55
1      4  2014    40
2      7  2013    84
3     10  2014    31
```

--------------------------------

### Get Start of Current Business Month with rollback

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BusinessMonthBegin.html

Uses rollback to get the start of the current business month. When the timestamp is already on the first business day, rollback returns the same date.

```python
>>> ts = pd.Timestamp(2022, 12, 1)
>>> pd.offsets.BMonthBegin().rollback(ts)
Timestamp('2022-12-01 00:00:00')
```

--------------------------------

### Create a Timestamp and import Second

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.Second.html

Shows how to import the Second offset and create a base Timestamp for the examples.

```python
>>> from pandas.tseries.offsets import Second
>>> ts = pd.Timestamp(2022, 12, 9, 15)
>>> ts
Timestamp('2022-12-09 15:00:00')
```

--------------------------------

### Get BusinessHour start time

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BusinessHour.start.html

Shows the default start time of a BusinessHour offset, which is 9:00 AM.

```python
>>> pd.offsets.BusinessHour().start
(datetime.time(9, 0),)
```

--------------------------------

### Displaying HDFStore information

Source: https://pandas.pydata.org/docs/reference/api/pandas.HDFStore.info.html

This example demonstrates creating an HDFStore, adding two DataFrames, and printing the store's information summary.

```python
>>> df1 = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=["C", "D"])
>>> store = pd.HDFStore("store.h5", "w")
>>> store.put("data1", df1)
>>> store.put("data2", df2)
>>> print(store.info())
>>> store.close()
<class 'pandas.io.pytables.HDFStore'>
File path: store.h5
/data1            frame        (shape->[2,2])
/data2            frame        (shape->[2,2])
```

--------------------------------

### Get default starting month for QuarterEnd

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BQuarterEnd.startingMonth.html

Returns the default starting month (3) for a QuarterEnd offset.

```python
>>> pd.offsets.QuarterEnd().startingMonth
3
```

--------------------------------

### Get default starting month for BQuarterBegin

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BQuarterEnd.startingMonth.html

Returns the default starting month (3) for a BQuarterBegin offset.

```python
>>> pd.offsets.BQuarterBegin().startingMonth
3
```

--------------------------------

### Example: Create DataFrame and apply rank methods

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.DataFrameGroupBy.rank.html

Creates a DataFrame with group and value columns, then applies the rank method with different method options (average, min, max, dense, first) to each group. The example shows the resulting DataFrame with the rank columns.

```python
>>> df = pd.DataFrame(
...     {
...         "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"],
...         "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5],
...     }
... )
>>> df
  group  value
0     a      2
1     a      4
2     a      2
3     a      3
4     a      5
5     b      1
6     b      2
7     b      4
8     b      1
9     b      5
>>> for method in ["average", "min", "max", "dense", "first"]:
...     df[f"{method}_rank"] = df.groupby("group")["value"].rank(method)
>>> df
  group  value  average_rank  min_rank  max_rank  dense_rank  first_rank
0     a      2           1.5       1.0       2.0         1.0         1.0
1     a      4           4.0       4.0       4.0         3.0         4.0
2     a      2           1.5       1.0       2.0         1.0         2.0
3     a      3           3.0       3.0       3.0         2.0         3.0
4     a      5           5.0       5.0       5.0         4.0         5.0
5     b      1           1.5       1.0       2.0         1.0         1.0
6     b      2           3.0       3.0       3.0         2.0         3.0
7     b      4           4.0       4.0       4.0         3.0         4.0
8     b      1           1.5       1.0       2.0         1.0         2.0
9     b      5           5.0       5.0       5.0         4.0         5.0
```

--------------------------------

### Create example DataFrame

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.le.html

Creates the example DataFrame used throughout the documentation. The DataFrame has columns 'cost' and 'revenue' with index labels 'A', 'B', and 'C'.

```python
>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
   cost  revenue
A   250      100
B   150      250
C   100      300

```

--------------------------------

### Example: Get UTC offset with Timestamp.utcoffset()

Source: https://pandas.pydata.org/docs/reference/api/pandas.Timestamp.utcoffset.html

Shows how to create a timezone-aware Timestamp and call utcoffset() to get the UTC offset as a timedelta. The example uses the Europe/Brussels timezone and returns a timedelta of 3600 seconds (1 hour).

```python
>>> ts = pd.Timestamp('2023-01-01 10:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2023-01-01 10:00:00+0100', tz='Europe/Brussels')
>>> ts.utcoffset()
datetime.timedelta(seconds=3600)
```

--------------------------------

### Series.all examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.all.html

Demonstrates the behavior of Series.all with various inputs: all True, mixed True/False, empty Series, and NaN handling with skipna default and skipna=False.

```python
>>> pd.Series([True, True]).all()
True
>>> pd.Series([True, False]).all()
False
>>> pd.Series([], dtype="float64").all()
True
>>> pd.Series([np.nan]).all()
True
>>> pd.Series([np.nan]).all(skipna=False)
True
```

--------------------------------

### Create and read sample CSV with pandas

Source: https://pandas.pydata.org/docs/user_guide/io.html?highlight=storage_options

Creates a sample DataFrame, writes it to a CSV file, and reads it back to show the data used in the chunked iteration examples. The output shows the full 10-row table.

```python
In [212]: df = pd.DataFrame(np.random.randn(10, 4))

In [213]: df.to_csv("tmp.csv", index=False)

In [214]: table = pd.read_csv("tmp.csv")

In [215]: table
Out[215]: 
          0         1         2         3
0 -1.294524  0.413738  0.276662 -0.472035
1 -0.013960 -0.362543 -0.006154 -0.923061
2  0.895717  0.805244 -1.206412  2.565646
3  1.431256  1.340309 -1.170299 -0.226169
4  0.410835  0.813850  0.132003 -0.827317
5 -0.076467 -1.187678  1.130127 -1.436737
6 -1.413681  1.607920  1.024180  0.569605
7  0.875906 -2.211372  0.974466 -2.006747
8 -0.410001 -0.078638  0.545952 -1.219217
9 -1.226825  0.769804 -1.281247 -0.727707
```

--------------------------------

### Series to_list() example

Source: https://pandas.pydata.org/docs/reference/api/pandas.Index.to_list.html

Example for Series: creates a Series and calls to_list() to get a list of Python scalars.

```python
>>> s = pd.Series([1, 2, 3])
>>> s.to_list()
[1, 2, 3]
```

--------------------------------

### Rollback to start of current year with YearBegin().rollback

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.YearBegin.html

Use rollback to get the start of the current year when the timestamp is already on that start. Note that with a timestamp not on the offset it rolls back to the previous year's start.

```python
>>> ts = pd.Timestamp(2023, 1, 1)
>>> pd.offsets.YearBegin().rollback(ts)
Timestamp('2023-01-01 00:00:00')

```

--------------------------------

### Get custom starting month for QuarterBegin

Source: https://pandas.pydata.org/docs/reference/api/pandas.tseries.offsets.BQuarterEnd.startingMonth.html

Returns the custom starting month (1) when specified via the startingMonth parameter.

```python
>>> pd.offsets.QuarterBegin(startingMonth=1).startingMonth
1
```

--------------------------------

### Create store/product DataFrame for pipe example

Source: https://pandas.pydata.org/docs/user_guide/groupby.html

Creates a DataFrame with columns for stores, products, revenue, and quantity sold. The data is used for groupwise price calculations (revenue/quantity) per store and product.

```python
In [264]: n = 1000

In [265]: df = pd.DataFrame(
   .....:     {
   .....:         "Store": np.random.choice(["Store_1", "Store_2"], n),
   .....:         "Product": np.random.choice(["Product_1", "Product_2"], n),
   .....:         "Revenue": (np.random.random(n) * 50 + 10).round(2),
   .....:         "Quantity": np.random.randint(1, 10, size=n),
   .....:     }
   .....: )
   .....: 

In [266]: df.head(2)
Out[266]: 
     Store    Product  Revenue  Quantity
0  Store_2  Product_1    26.12         1
1  Store_2  Product_1    28.86         1
```

--------------------------------

### Create Series for concatenation example

Source: https://pandas.pydata.org/docs/whatsnew/v0.24.0.html

Setup for the concatenation example: creates a float Series and a categorical Series with NaN values.

```python
In [96]: s = pd.Series([0, 1, np.nan])

In [97]: c = pd.Series([0, 1, np.nan], dtype="category")
```

--------------------------------

### Creating sample DataFrame for groupby and pipe example

Source: https://pandas.pydata.org/docs/whatsnew/v0.21.0.html

Creates a sample DataFrame with columns for stores, products, revenue, and quantity. This data is used in the following example to demonstrate combining .groupby and .pipe.

```python
In [26]: import numpy as np

In [27]: n = 1000

In [28]: df = pd.DataFrame({'Store': np.random.choice(['Store_1', 'Store_2'], n),
   ....:                    'Product': np.random.choice(['Product_1',
   ....:                                                 'Product_2',
   ....:                                                 'Product_3'
   ....:                                                 ], n),
   ....:                    'Revenue': (np.random.random(n) * 50 + 10).round(2),
   ....:                    'Quantity': np.random.randint(1, 10, size=n)})
   ....: 

In [29]: df.head(2)
Out[29]: 
     Store    Product  Revenue  Quantity
0  Store_2  Product_2    32.09         7
1  Store_1  Product_3    14.20         1

[2 rows x 4 columns]
```

--------------------------------

### Retrieve an object from HDFStore with get()

Source: https://pandas.pydata.org/docs/reference/api/pandas.HDFStore.get.html

Creates a DataFrame, stores it in an HDFStore file, retrieves it with get(), and closes the store. The get() call returns the stored object; the example does not show the output.

```python
>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
>>> store = pd.HDFStore("store.h5", "w")
>>> store.put("data", df)
>>> store.get("data")
>>> store.close()
```

--------------------------------

### Create a sample DataFrame for take() examples

Source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.take.html

Constructs a DataFrame with columns 'name', 'class', and 'max_speed' and a custom index [0, 2, 3, 1]. This DataFrame is used in the subsequent take() examples.

```python
>>> df = pd.DataFrame(
...     [
...         ("falcon", "bird", 389.0),
...         ("parrot", "bird", 24.0),
...         ("lion", "mammal", 80.5),
...         ("monkey", "mammal", np.nan),
...     ],
...     columns=["name", "class", "max_speed"],
...     index=[0, 2, 3, 1],
... )
>>> df
     name   class  max_speed
0  falcon    bird      389.0
2  parrot    bird       24.0
3    lion  mammal       80.5
1  monkey  mammal        NaN
```

--------------------------------

### Index to_list() example

Source: https://pandas.pydata.org/docs/reference/api/pandas.Index.to_list.html

Example for Index: creates an Index, shows its representation, then calls to_list() to get a list of Python scalars.

```python
>>> idx = pd.Index([1, 2, 3])
>>> idx
Index([1, 2, 3], dtype='int64')
```

```python
>>> idx.to_list()
[1, 2, 3]
```

--------------------------------

### Create sample DataFrame

Source: https://pandas.pydata.org/docs/reference/api/pandas.api.typing.SeriesGroupBy.pipe.html

Creates a sample DataFrame with columns A and B in the examples section, showing the resulting printed output. Used as input for the pipe example that follows.

```python
>>> df = pd.DataFrame({"A": "a b a b".split(), "B": [1, 2, 3, 4]})
>>> df
   A  B
0  a  1
1  b  2
2  a  3
3  b  4
```
Tokens:
Raw