richard
/
python-cheatsheet
mirror of https://github.com/gto76/python-cheatsheet.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Working on Pandas

pull/57/head
Jure Šorn 4 years ago
parent
a1b1276724
commit
db9ba04264
2 changed files with 259 additions and 159 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 206
      README.md
  2. 212
      index.html

206
README.md
View File

@ -3088,11 +3088,6 @@ Name: a, dtype: int64
<Sr> = Series(<dict/Series>, index=<list>) # Only keeps items with keys specified in index.
```
```python
keys = <Sr>.index # Returns a sequence of keys as Index object.
vals = <Sr>.values # Returns a sequence of values as numpy array.
```
```python
<el> = <Sr>.loc[key] # Or: <Sr>.iloc[index]
<Sr> = <Sr>.loc[keys] # Or: <Sr>.iloc[indexes]
@ -3102,20 +3097,37 @@ vals = <Sr>.values # Returns a sequence of values as
```python
<el> = <Sr>[key/index] # Or: <Sr>.key
<Sr> = <Sr>[keys/indexes] # Or: <Sr>[<key_range/range>]
<Sr> = <Sr>[<bools>] # Or: <Sr>.i/loc[<bools>]
<Sr> = <Sr>[bools] # Or: <Sr>.i/loc[bools]
```
```python
<Sr> = <Sr> ><== <el/Sr> # Returns Series of bools.
<Sr> = <Sr> ><== <el/Sr> # Returns a Series of bools.
<Sr> = <Sr> +-*/ <el/Sr> # Non-matching keys get value NaN.
```
```python
<Sr> = pd.concat(<coll_of_Sr>) # Combines items.
<Sr> = <Sr>.append(<Sr>) # Appends new items.
<Sr> = <Sr>.append(<Sr>) # Or: pd.concat(<coll_of_Sr>)
<Sr> = <Sr>.combine_first(<Sr>) # Adds items that are not yet present (extends).
```
#### Operations:
```python
<el> = <Sr>.sum/max/mean/idxmax/all()
<Sr> = <Sr>.diff/cumsum/rank/pct_change() # …/fillna/ffill/interpolate()
<el> = <Sr>.apply/agg(<agg_func>)
<Sr> = <Sr>.apply/agg/transform(<trans_func>)
```
```python
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | 'sum' | ['sum'] | {'s': 'sum'} | 'rank' | ['rank'] | {'r': 'rank'} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| sr.apply(…) | | | | | rank | |
| sr.agg(…) | 3 | sum 3 | s 3 | x 1 | x 1 | r x 1 |
| | | | | y 2 | y 2 | y 2 |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
```
### DataFrame
**Table with labeled rows and columns.**
@ -3127,41 +3139,58 @@ b 3 4
```
```python
<DF> = DataFrame(<list_of_rows>) # Rows can be either lists, dicts or series.
<DF> = DataFrame(<dict_of_columns>) # Columns can be either lists, dicts or series.
<DF> = DataFrame(<list_of_rows>) # Rows can be either lists, dicts or series.
<DF> = DataFrame(<dict_of_columns>) # Columns can be either lists, dicts or series.
```
```python
<el> = <DF>.loc[row_key, column_key] # Or: <DF>.iloc[row_index, column_index]
<Sr/DF> = <DF>.loc[row_key/s] # Or: <DF>.iloc[row_index/es]
<Sr/DF> = <DF>.loc[:, column_key/s] # Or: <DF>.iloc[:, column_index/es]
<DF> = <DF>.loc[row_bools, column_bools] # Or: <DF>.iloc[row_bools, column_bools]
```
```python
row_keys = <Sr>.index # Also: `col_keys = <Sr>.columns`.
values = <Sr>.values # Returns values as 2D numpy array.
<Sr/DF> = <DF>[column_key/s] # Or: <DF>.column_key
<DF> = <DF>[row_bools] # Keeps rows as specified by bools.
<DF> = <DF>[<DF_of_bools>] # Assigns NaN to False values.
```
```python
<el> = <DF>.loc[row_key, column_key] # Or: <DF>.iloc[row_index, column_index]
<Sr/DF> = <DF>.loc[row_key/s] # Or: <DF>.iloc[row_index/es]
<Sr/DF> = <DF>.loc[:, column_key/s] # Or: <DF>.iloc[:, column_index/es]
<DF> = <DF>.loc[row_bools, column_bools] # Or: <DF>.iloc[row_bools, column_bools]
<DF> = <DF> ><== <el/Sr/DF> # Returns DataFrame of bools.
<DF> = <DF> +-*/ <el/Sr/DF> # Non-matching keys get value NaN.
```
```python
<Sr/DF> = <DF>[column_key/s] # Or: <DF>.column_key
<DF> = <DF>[row_bools] # Keeps rows as specified by bools.
<DF> = <DF>[<DF_of_bools>] # Assigns NaN to False values.
<DF> = <DF>.set_index(column_key) # Replaces row keys with values from a column.
<DF> = <DF>.reset_index() # Moves row keys to their own column.
<DF> = <DF>.transpose() # Rotates the table.
<DF> = <DF>.melt(id_vars=column_key/s) # Melts on columns.
```
#### Operations:
```python
<DF> = <DF> ><== <el/Sr/DF> # Returns DataFrame of bools.
<DF> = <DF> +-*/ <el/Sr/DF> # Non-matching keys get value NaN.
<Sr> = <DF>.sum/max/mean/idxmax/all()
<DF> = <DF>.diff/cumsum/rank() # …/pct_change/fillna/ffill/interpolate()
<Sr> = <DF>.apply/agg/transform(<agg_func>)
<DF> = <DF>.apply/agg/transform(<trans_func>)
<DF> = <DF>.applymap(<func>) # Apply a function to a Dataframe elementwise.
```
* **All operations operate on columns by default. Use `'axis=1'` parameter to process the rows instead.**
```python
<DF> = <DF>.set_index(column_key) # Replaces row keys with values from a column.
<DF> = <DF>.reset_index() # Moves row keys to their own column.
<DF> = <DF>.transpose() # Rotates the table.
<DF> = <DF>.melt(id_vars=column_key/s) # Melts on columns.
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | 'sum' | ['sum'] | {'x': 'sum'} | 'rank' | ['rank'] | {'x': 'rank'} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| df.apply(…) | | x y | | x y | x y | x |
| df.agg(…) | x 4 | sum 4 6 | x 4 | a 1 1 | rank rank | a 1 |
| df.trans(…) | y 6 | | | b 2 2 | a 1 1 | b 2 |
| | | | | | b 2 2 | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
```
* **Transform doesen't work with `['sum']` and `{'x': 'sum'}`.**
### Merge, Join, Concat
#### Merge, Join, Concat:
```python
>>> l = DataFrame([[1, 2], [3, 4]], index=['a', 'b'], columns=['x', 'y'])
x y
@ -3172,74 +3201,95 @@ b 3 4
b 4 5
c 6 7
```
```python
┏━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┓
┃ how/join │ 'outer' │ 'inner' │ 'left' ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.merge(r, on='y', │ x y z │ x y z │ x y z ┃
┃ how=…) │ 0 1 2 . │ 3 4 5 │ 1 2 . ┃
┃ │ 1 3 4 5 │ │ 3 4 5 ┃
┃ │ 2 . 6 7 │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.join(r, lsuffix='l', │ x yl yr z │ │ x yl yr z ┃
┃ rsuffix='r', │ a 1 2 . . │ x yl yr z │ 1 2 . . ┃
┃ how=…) │ b 3 4 4 5 │ 3 4 4 5 │ 3 4 4 5 ┃
┃ │ c . . 6 7 │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ pd.concat([l, r], │ x y z │ y │ ┃
┃ axis=0, │ a 1 2 . │ 2 │ ┃
┃ join=…) │ b 3 4 . │ 4 │ ┃
┃ │ b . 4 5 │ 4 │ ┃
┃ │ c . 6 7 │ 6 │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ pd.concat([l, r], │ x y y z │ │ ┃
┃ axis=1, │ a 1 2 . . │ x y y z │ ┃
┃ join=…) │ b 3 4 4 5 │ 3 4 4 5 │ ┃
┃ │ c . . 6 7 │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.combine_first(r) │ x y z │ │ ┃
┃ │ a 1 2 . │ │ ┃
┃ │ b 3 4 5 │ │ ┃
┃ │ c . 6 7 │ │ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┛
┏━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ how/join │ 'outer' │ 'inner' │ 'left' │ description ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.merge(r, on='y', │ x y z │ x y z │ x y z │ Joins/merges on column. ┃
┃ how=…) │ 0 1 2 . │ 3 4 5 │ 1 2 . │ Also accepts left_on and ┃
┃ │ 1 3 4 5 │ │ 3 4 5 │ right_on parameters. ┃
┃ │ 2 . 6 7 │ │ │ Uses 'inner' by default. ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.join(r, lsuffix='l', │ x yl yr z │ │ x yl yr z │ Joins/merges on row_keys.┃
┃ rsuffix='r', │ a 1 2 . . │ x yl yr z │ 1 2 . . │ Uses 'left' by default. ┃
┃ how=…) │ b 3 4 4 5 │ 3 4 4 5 │ 3 4 4 5 │ ┃
┃ │ c . . 6 7 │ │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ pd.concat([l, r], │ x y z │ y │ │ Adds rows at the bottom. ┃
┃ axis=0, │ a 1 2 . │ 2 │ │ Uses 'outer' by default. ┃
┃ join=…) │ b 3 4 . │ 4 │ │ By default works the ┃
┃ │ b . 4 5 │ 4 │ │ same as `l.append(r)`. ┃
┃ │ c . 6 7 │ 6 │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ pd.concat([l, r], │ x y y z │ │ │ Adds columns at the ┃
┃ axis=1, │ a 1 2 . . │ x y y z │ │ right end. ┃
┃ join=…) │ b 3 4 4 5 │ 3 4 4 5 │ │ Uses 'outer' by default. ┃
┃ │ c . . 6 7 │ │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.combine_first(r) │ x y z │ │ │ Adds missing rows and ┃
┃ │ a 1 2 . │ │ │ columns. ┃
┃ │ b 3 4 5 │ │ │ ┃
┃ │ c . 6 7 │ │ │ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━┛
```
### GroupBy
**Object that groups together rows of a dataframe based on the value of passed column.**
```python
<DF_Gb> = <DF>.groupby(column_key/s) # Columns that were used for groupin becme row_k.
<DFs> = list(<DF_Gb>) # Returns list of group_key - DataFrame tuples.
<DF> = <DF_Gb>.get_group(group_key)
<Sr_Gb> = <DF_Gb>[column_key] # Or: <DF_Gb>.column_key
<Srs> = list(<Sr_Gb>) # Returns list of group_key - Series tuples.
>>> df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 6]], index=list('abc'), columns=list('xyz'))
>>> gb = df.groupby('z')
x y z
3: a 1 2 3
6: b 4 5 6
c 7 8 6
```
### Operations
```python
<el/Sr/DF> = <Sr/DF/GB>.sum/max/mean() # …/idxmax/all()
<Sr/DF> = <Sr/DF/GB>.diff/cumsum/rank() # …/pct_change()
<GB> = <DF>.groupby(column_key/s) # DF is split into groups based on passed column.
<DF> = <GB>.get_group(group_key) # Selects a group by value of grouping column.
<DF> = <GB>.<operation>() # Executes operation on each col of each group.
```
* **Result of an operation is a dataframe with index made up of group keys. Use `'<DF>.reset_index()'` to move the index back into it's own column.**
#### Operations:
```python
<Sr/DF> = <Sr/DF/GB>.ffill()
<Sr/DF> = <Sr/DF/GB>.fillna(value)
<Sr/DF> = <Sr/DF>.interpolate()
<DF> = <GB>.sum/max/mean/idxmax/all()
<DF> = <GB>.diff/cumsum/rank() # …/pct_change/fillna/ffill()
<DF> = <GB>.apply/agg/transform(<agg_func>)
<DF> = <GB>.agg/transform(<trans_func>)
```
```python
<Sr/DF> = <Sr/DF/GB>.apply(<func>) # Invokes function on every value/column/group.
<DF> = <DF>.applymap(<func>) # Apply a function to a Dataframe elementwise.
<Sr/DF> = <Sr/DF/GB>.aggregate(<func>) # Invokes function on every column > number.
<Sr/DF> = <Sr/DF/GB>.transform(<func>)
<Sr/DF> = <Sr/DF>.combine(<Sr/DF>, <func>)
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | 'sum' | ['sum'] | {'x': 'sum'} | 'rank' | ['rank'] | {'x': 'rank'} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.apply(…) | x y z | | | | | |
| | z | | | | | |
| | 3 1 2 3 | | | | | |
| | 6 11 13 12 | | | | | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.agg(…) | x y | x y | x | x y | x y | x |
| | z | sum sum | z | a 1 1 | rank rank | a 1 |
| | 3 1 2 | z | 3 1 | b 1 1 | a 1 1 | b 1 |
| | 6 11 13 | 3 1 2 | 6 11 | c 2 2 | b 1 1 | c 2 |
| | | 6 11 13 | | | c 2 2 | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.trans(…) | x y | | | x y | | |
| | a 1 2 | | | a 1 1 | | |
| | b 11 13 | | | b 1 1 | | |
| | c 11 13 | | | c 1 1 | | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
```
### Rolling
```python
<Rl> = <Sr/DF/GB>.rolling(window_size) # Also: `min_periods, center=False`.
<Rl> = <Rl>[column_key/s] # Or: <Rl>.column_key
<Sr/DF> = <Rl>.sum/max/mean()
<Sr/DF> = <Rl>.apply(<func>) # Invokes function on every window.
<Sr/DF> = <Rl>.aggregate(<func>) # Invokes function on every window.
<Rl_S/D/G> = <Sr/DF/GB>.rolling(window_size) # Also: `min_periods=None, center=False`.
<Rl_S/D> = <Rl_D/G>[column_key/s] # Or: <Rl>.column_key
<Sr/DF/DF> = <Rl_S/D/G>.sum/max/mean()
<Sr/DF/DF> = <Rl_S/D/G>.apply(<func>) # Invokes function on every window.
<Sr/DF/DF> = <Rl_S/D/G>.aggregate(<func/str>) # Invokes function on every window.
```
### Encode
@ -3353,7 +3403,7 @@ def mangle_data(covid, dow_jones, gold, bitcoin):
out = pandas.concat([covid, dow_jones, gold, bitcoin], axis=1)
out = out.loc['2020-02-23':].iloc[:-2]
out = out.interpolate()
out.iloc[:, 1:] = out.rolling(10, 1, center=True).mean().iloc[:, 1:]
out.iloc[:, 1:] = out.rolling(10, min_periods=1, center=True).mean().iloc[:, 1:]
out.iloc[:, 1:] = out.iloc[:, 1:] / out.iloc[0, 1:] * 100
return out

212
index.html
View File

@ -2624,24 +2624,34 @@ Name: a, dtype: int64
&lt;Sr&gt; = Series(&lt;dict&gt;) <span class="hljs-comment"># Takes dictionary's keys for index.</span>
&lt;Sr&gt; = Series(&lt;dict/Series&gt;, index=&lt;list&gt;) <span class="hljs-comment"># Only keeps items with keys specified in index.</span>
</code></pre>
<pre><code class="python language-python hljs">keys = &lt;Sr&gt;.index <span class="hljs-comment"># Returns a sequence of keys as Index object.</span>
vals = &lt;Sr&gt;.values <span class="hljs-comment"># Returns a sequence of values as numpy array.</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;el&gt; = &lt;Sr&gt;.loc[key] <span class="hljs-comment"># Or: &lt;Sr&gt;.iloc[index]</span>
&lt;Sr&gt; = &lt;Sr&gt;.loc[keys] <span class="hljs-comment"># Or: &lt;Sr&gt;.iloc[indexes]</span>
&lt;Sr&gt; = &lt;Sr&gt;.loc[from_key : to_key_inclusive] <span class="hljs-comment"># Or: &lt;Sr&gt;.iloc[from_i : to_i_exclusive]</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;el&gt; = &lt;Sr&gt;[key/index] <span class="hljs-comment"># Or: &lt;Sr&gt;.key</span>
&lt;Sr&gt; = &lt;Sr&gt;[keys/indexes] <span class="hljs-comment"># Or: &lt;Sr&gt;[&lt;key_range/range&gt;]</span>
&lt;Sr&gt; = &lt;Sr&gt;[&lt;bools&gt;] <span class="hljs-comment"># Or: &lt;Sr&gt;.i/loc[&lt;bools&gt;]</span>
&lt;Sr&gt; = &lt;Sr&gt;[bools] <span class="hljs-comment"># Or: &lt;Sr&gt;.i/loc[bools]</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;Sr&gt; = &lt;Sr&gt; &gt;&lt;== &lt;el/Sr&gt; <span class="hljs-comment"># Returns Series of bools.</span>
<pre><code class="python language-python hljs">&lt;Sr&gt; = &lt;Sr&gt; &gt;&lt;== &lt;el/Sr&gt; <span class="hljs-comment"># Returns a Series of bools.</span>
&lt;Sr&gt; = &lt;Sr&gt; +-*/ &lt;el/Sr&gt; <span class="hljs-comment"># Non-matching keys get value NaN.</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;Sr&gt; = pd.concat(&lt;coll_of_Sr&gt;) <span class="hljs-comment"># Combines items.</span>
&lt;Sr&gt; = &lt;Sr&gt;.append(&lt;Sr&gt;) <span class="hljs-comment"># Appends new items.</span>
<pre><code class="python language-python hljs">&lt;Sr&gt; = &lt;Sr&gt;.append(&lt;Sr&gt;) <span class="hljs-comment"># Or: pd.concat(&lt;coll_of_Sr&gt;)</span>
&lt;Sr&gt; = &lt;Sr&gt;.combine_first(&lt;Sr&gt;) <span class="hljs-comment"># Adds items that are not yet present (extends).</span>
</code></pre>
<div><h4 id="operations">Operations:</h4><pre><code class="python language-python hljs">&lt;el&gt; = &lt;Sr&gt;.sum/max/mean/idxmax/all()
&lt;Sr&gt; = &lt;Sr&gt;.diff/cumsum/rank/pct_change() <span class="hljs-comment"># …/fillna/ffill/interpolate()</span>
&lt;el&gt; = &lt;Sr&gt;.apply/agg(&lt;agg_func&gt;)
&lt;Sr&gt; = &lt;Sr&gt;.apply/agg/transform(&lt;trans_func&gt;)
</code></pre></div>
<pre><code class="python language-python hljs">+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | <span class="hljs-string">'sum'</span> | [<span class="hljs-string">'sum'</span>] | {<span class="hljs-string">'s'</span>: <span class="hljs-string">'sum'</span>} | <span class="hljs-string">'rank'</span> | [<span class="hljs-string">'rank'</span>] | {<span class="hljs-string">'r'</span>: <span class="hljs-string">'rank'</span>} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| sr.apply(…) | | | | | rank | |
| sr.agg(…) | <span class="hljs-number">3</span> | sum <span class="hljs-number">3</span> | s <span class="hljs-number">3</span> | x <span class="hljs-number">1</span> | x <span class="hljs-number">1</span> | r x <span class="hljs-number">1</span> |
| | | | | y <span class="hljs-number">2</span> | y <span class="hljs-number">2</span> | y <span class="hljs-number">2</span> |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
</code></pre>
<div><h3 id="dataframe">DataFrame</h3><p><strong>Table with labeled rows and columns.</strong></p><pre><code class="python language-python hljs"><span class="hljs-meta">&gt;&gt;&gt; </span>DataFrame([[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>]], index=[<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], columns=[<span class="hljs-string">'x'</span>, <span class="hljs-string">'y'</span>])
x y
a <span class="hljs-number">1</span> <span class="hljs-number">2</span>
@ -2649,30 +2659,49 @@ b <span class="hljs-number">3</span> <span class="hljs-number">4</span>
</code></pre></div>
<pre><code class="python language-python hljs">&lt;DF&gt; = DataFrame(&lt;list_of_rows&gt;) <span class="hljs-comment"># Rows can be either lists, dicts or series.</span>
&lt;DF&gt; = DataFrame(&lt;dict_of_columns&gt;) <span class="hljs-comment"># Columns can be either lists, dicts or series.</span>
<pre><code class="python language-python hljs">&lt;DF&gt; = DataFrame(&lt;list_of_rows&gt;) <span class="hljs-comment"># Rows can be either lists, dicts or series.</span>
&lt;DF&gt; = DataFrame(&lt;dict_of_columns&gt;) <span class="hljs-comment"># Columns can be either lists, dicts or series.</span>
</code></pre>
<pre><code class="python language-python hljs">row_keys = &lt;Sr&gt;.index <span class="hljs-comment"># Also: `col_keys = &lt;Sr&gt;.columns`.</span>
values = &lt;Sr&gt;.values <span class="hljs-comment"># Returns values as 2D numpy array.</span>
<pre><code class="python language-python hljs">&lt;el&gt; = &lt;DF&gt;.loc[row_key, column_key] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_index, column_index]</span>
&lt;Sr/DF&gt; = &lt;DF&gt;.loc[row_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_index/es]</span>
&lt;Sr/DF&gt; = &lt;DF&gt;.loc[:, column_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[:, column_index/es]</span>
&lt;DF&gt; = &lt;DF&gt;.loc[row_bools, column_bools] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_bools, column_bools]</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;el&gt; = &lt;DF&gt;.loc[row_key, column_key] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_index, column_index]</span>
&lt;Sr/DF&gt; = &lt;DF&gt;.loc[row_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_index/es]</span>
&lt;Sr/DF&gt; = &lt;DF&gt;.loc[:, column_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[:, column_index/es]</span>
&lt;DF&gt; = &lt;DF&gt;.loc[row_bools, column_bools] <span class="hljs-comment"># Or: &lt;DF&gt;.iloc[row_bools, column_bools]</span>
<pre><code class="python language-python hljs">&lt;Sr/DF&gt; = &lt;DF&gt;[column_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.column_key</span>
&lt;DF&gt; = &lt;DF&gt;[row_bools] <span class="hljs-comment"># Keeps rows as specified by bools.</span>
&lt;DF&gt; = &lt;DF&gt;[&lt;DF_of_bools&gt;] <span class="hljs-comment"># Assigns NaN to False values.</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;Sr/DF&gt; = &lt;DF&gt;[column_key/s] <span class="hljs-comment"># Or: &lt;DF&gt;.column_key</span>
&lt;DF&gt; = &lt;DF&gt;[row_bools] <span class="hljs-comment"># Keeps rows as specified by bools.</span>
&lt;DF&gt; = &lt;DF&gt;[&lt;DF_of_bools&gt;] <span class="hljs-comment"># Assigns NaN to False values.</span>
<pre><code class="python language-python hljs">&lt;DF&gt; = &lt;DF&gt; &gt;&lt;== &lt;el/Sr/DF&gt; <span class="hljs-comment"># Returns DataFrame of bools.</span>
&lt;DF&gt; = &lt;DF&gt; +-*/ &lt;el/Sr/DF&gt; <span class="hljs-comment"># Non-matching keys get value NaN.</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;DF&gt; = &lt;DF&gt; &gt;&lt;== &lt;el/Sr/DF&gt; <span class="hljs-comment"># Returns DataFrame of bools.</span>
&lt;DF&gt; = &lt;DF&gt; +-*/ &lt;el/Sr/DF&gt; <span class="hljs-comment"># Non-matching keys get value NaN.</span>
<pre><code class="python language-python hljs">&lt;DF&gt; = &lt;DF&gt;.set_index(column_key) <span class="hljs-comment"># Replaces row keys with values from a column.</span>
&lt;DF&gt; = &lt;DF&gt;.reset_index() <span class="hljs-comment"># Moves row keys to their own column.</span>
&lt;DF&gt; = &lt;DF&gt;.transpose() <span class="hljs-comment"># Rotates the table.</span>
&lt;DF&gt; = &lt;DF&gt;.melt(id_vars=column_key/s) <span class="hljs-comment"># Melts on columns.</span>
</code></pre>
<pre><code class="python language-python hljs">&lt;DF&gt; = &lt;DF&gt;.set_index(column_key) <span class="hljs-comment"># Replaces row keys with values from a column.</span>
&lt;DF&gt; = &lt;DF&gt;.reset_index() <span class="hljs-comment"># Moves row keys to their own column.</span>
&lt;DF&gt; = &lt;DF&gt;.transpose() <span class="hljs-comment"># Rotates the table.</span>
&lt;DF&gt; = &lt;DF&gt;.melt(id_vars=column_key/s) <span class="hljs-comment"># Melts on columns.</span>
<div><h4 id="operations-1">Operations:</h4><pre><code class="python language-python hljs">&lt;Sr&gt; = &lt;DF&gt;.sum/max/mean/idxmax/all()
&lt;DF&gt; = &lt;DF&gt;.diff/cumsum/rank() <span class="hljs-comment"># …/pct_change/fillna/ffill/interpolate()</span>
&lt;Sr&gt; = &lt;DF&gt;.apply/agg/transform(&lt;agg_func&gt;)
&lt;DF&gt; = &lt;DF&gt;.apply/agg/transform(&lt;trans_func&gt;)
&lt;DF&gt; = &lt;DF&gt;.applymap(&lt;func&gt;) <span class="hljs-comment"># Apply a function to a Dataframe elementwise.</span>
</code></pre></div>
<ul>
<li><strong>All operations operate on columns by default. Use <code class="python hljs"><span class="hljs-string">'axis=1'</span></code> parameter to process the rows instead.</strong> </li>
</ul>
<pre><code class="python language-python hljs">+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | <span class="hljs-string">'sum'</span> | [<span class="hljs-string">'sum'</span>] | {<span class="hljs-string">'x'</span>: <span class="hljs-string">'sum'</span>} | <span class="hljs-string">'rank'</span> | [<span class="hljs-string">'rank'</span>] | {<span class="hljs-string">'x'</span>: <span class="hljs-string">'rank'</span>} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| df.apply(…) | | x y | | x y | x y | x |
| df.agg(…) | x <span class="hljs-number">4</span> | sum <span class="hljs-number">4</span> <span class="hljs-number">6</span> | x <span class="hljs-number">4</span> | a <span class="hljs-number">1</span> <span class="hljs-number">1</span> | rank rank | a <span class="hljs-number">1</span> |
| df.trans(…) | y <span class="hljs-number">6</span> | | | b <span class="hljs-number">2</span> <span class="hljs-number">2</span> | a <span class="hljs-number">1</span> <span class="hljs-number">1</span> | b <span class="hljs-number">2</span> |
| | | | | | b <span class="hljs-number">2</span> <span class="hljs-number">2</span> | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
</code></pre>
<div><h3 id="mergejoinconcat">Merge, Join, Concat</h3><pre><code class="python language-python hljs"><span class="hljs-meta">&gt;&gt;&gt; </span>l = DataFrame([[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>]], index=[<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], columns=[<span class="hljs-string">'x'</span>, <span class="hljs-string">'y'</span>])
<ul>
<li><strong>Transform doesen't work with <code class="python hljs">[<span class="hljs-string">'sum'</span>]</code> and <code class="python hljs">{<span class="hljs-string">'x'</span>: <span class="hljs-string">'sum'</span>}</code>.</strong></li>
</ul>
<div><h4 id="mergejoinconcat">Merge, Join, Concat:</h4><pre><code class="python language-python hljs"><span class="hljs-meta">&gt;&gt;&gt; </span>l = DataFrame([[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>]], index=[<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], columns=[<span class="hljs-string">'x'</span>, <span class="hljs-string">'y'</span>])
x y
a <span class="hljs-number">1</span> <span class="hljs-number">2</span>
b <span class="hljs-number">3</span> <span class="hljs-number">4</span>
@ -2682,62 +2711,83 @@ b <span class="hljs-number">4</span> <span class="hljs-number">5</span>
c <span class="hljs-number">6</span> <span class="hljs-number">7</span>
</code></pre></div>
<pre><code class="python language-python hljs">┏━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┓
┃ how/join │ <span class="hljs-string">'outer'</span> │ <span class="hljs-string">'inner'</span> │ <span class="hljs-string">'left'</span> ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.merge(r, on=<span class="hljs-string">'y'</span>, │ x y z │ x y z │ x y z ┃
┃ how=…) │ <span class="hljs-number">0</span> <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">1</span> <span class="hljs-number">2</span> . ┃
┃ │ <span class="hljs-number">1</span> <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> ┃
┃ │ <span class="hljs-number">2</span> . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.join(r, lsuffix=<span class="hljs-string">'l'</span>, │ x yl yr z │ │ x yl yr z ┃
┃ rsuffix=<span class="hljs-string">'r'</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . │ x yl yr z │ <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . ┃
┃ how=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> ┃
┃ │ c . . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ pd.concat([l, r], │ x y z │ y │ ┃
┃ axis=<span class="hljs-number">0</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ <span class="hljs-number">2</span> │ ┃
┃ join=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> . │ <span class="hljs-number">4</span> │ ┃
┃ │ b . <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">4</span> │ ┃
┃ │ c . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ <span class="hljs-number">6</span> │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ pd.concat([l, r], │ x y y z │ │ ┃
┃ axis=<span class="hljs-number">1</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . │ x y y z │ ┃
┃ join=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ ┃
┃ │ c . . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┨
┃ l.combine_first(r) │ x y z │ │ ┃
┃ │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ │ ┃
┃ │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ │ ┃
┃ │ c . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┛
</code></pre>
<div><h3 id="groupby">GroupBy</h3><pre><code class="python language-python hljs">&lt;DF_Gb&gt; = &lt;DF&gt;.groupby(column_key/s) <span class="hljs-comment"># Columns that were used for groupin becme row_k.</span>
&lt;DFs&gt; = list(&lt;DF_Gb&gt;) <span class="hljs-comment"># Returns list of group_key - DataFrame tuples.</span>
&lt;DF&gt; = &lt;DF_Gb&gt;.get_group(group_key)
&lt;Sr_Gb&gt; = &lt;DF_Gb&gt;[column_key] <span class="hljs-comment"># Or: &lt;DF_Gb&gt;.column_key</span>
&lt;Srs&gt; = list(&lt;Sr_Gb&gt;) <span class="hljs-comment"># Returns list of group_key - Series tuples.</span>
</code></pre></div>
<div><h3 id="operations">Operations</h3><pre><code class="python language-python hljs">&lt;el/Sr/DF&gt; = &lt;Sr/DF/GB&gt;.sum/max/mean() <span class="hljs-comment"># …/idxmax/all()</span>
&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.diff/cumsum/rank() <span class="hljs-comment"># …/pct_change()</span>
</code></pre></div>
<pre><code class="python language-python hljs">&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.ffill()
&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.fillna(value)
&lt;Sr/DF&gt; = &lt;Sr/DF&gt;.interpolate()
</code></pre>
<pre><code class="python language-python hljs">&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.apply(&lt;func&gt;) <span class="hljs-comment"># Invokes function on every value/column/group.</span>
&lt;DF&gt; = &lt;DF&gt;.applymap(&lt;func&gt;) <span class="hljs-comment"># Apply a function to a Dataframe elementwise.</span>
&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.aggregate(&lt;func&gt;) <span class="hljs-comment"># Invokes function on every column &gt; number.</span>
&lt;Sr/DF&gt; = &lt;Sr/DF/GB&gt;.transform(&lt;func&gt;)
&lt;Sr/DF&gt; = &lt;Sr/DF&gt;.combine(&lt;Sr/DF&gt;, &lt;func&gt;)
<pre><code class="python language-python hljs">┏━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ how/join │ <span class="hljs-string">'outer'</span> │ <span class="hljs-string">'inner'</span> │ <span class="hljs-string">'left'</span> │ description ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.merge(r, on=<span class="hljs-string">'y'</span>, │ x y z │ x y z │ x y z │ Joins/merges on column. ┃
┃ how=…) │ <span class="hljs-number">0</span> <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ Also accepts left_on <span class="hljs-keyword">and</span> ┃
┃ │ <span class="hljs-number">1</span> <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ right_on parameters. ┃
┃ │ <span class="hljs-number">2</span> . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ │ Uses <span class="hljs-string">'inner'</span> by default. ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.join(r, lsuffix=<span class="hljs-string">'l'</span>, │ x yl yr z │ │ x yl yr z │ Joins/merges on row_keys.┃
┃ rsuffix=<span class="hljs-string">'r'</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . │ x yl yr z │ <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . │ Uses <span class="hljs-string">'left'</span> by default. ┃
┃ how=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ ┃
┃ │ c . . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ pd.concat([l, r], │ x y z │ y │ │ Adds rows at the bottom. ┃
┃ axis=<span class="hljs-number">0</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ <span class="hljs-number">2</span> │ │ Uses <span class="hljs-string">'outer'</span> by default. ┃
┃ join=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> . │ <span class="hljs-number">4</span> │ │ By default works the ┃
┃ │ b . <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">4</span> │ │ same <span class="hljs-keyword">as</span> `l.append(r)`. ┃
┃ │ c . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ <span class="hljs-number">6</span> │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ pd.concat([l, r], │ x y y z │ │ │ Adds columns at the ┃
┃ axis=<span class="hljs-number">1</span>, │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . . │ x y y z │ │ right end. ┃
┃ join=…) │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ │ Uses <span class="hljs-string">'outer'</span> by default. ┃
┃ │ c . . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ │ ┃
┠────────────────────────┼───────────────┼────────────┼────────────┼──────────────────────────┨
┃ l.combine_first(r) │ x y z │ │ │ Adds missing rows <span class="hljs-keyword">and</span> ┃
┃ │ a <span class="hljs-number">1</span> <span class="hljs-number">2</span> . │ │ │ columns. ┃
┃ │ b <span class="hljs-number">3</span> <span class="hljs-number">4</span> <span class="hljs-number">5</span> │ │ │ ┃
┃ │ c . <span class="hljs-number">6</span> <span class="hljs-number">7</span> │ │ │ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━┛
</code></pre>
<div><h3 id="groupby">GroupBy</h3><p><strong>Object that groups together rows of a dataframe based on the value of passed column.</strong></p><pre><code class="python language-python hljs"><span class="hljs-meta">&gt;&gt;&gt; </span>df = DataFrame([[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>], [<span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">6</span>]], index=list(<span class="hljs-string">'abc'</span>), columns=list(<span class="hljs-string">'xyz'</span>))
<span class="hljs-meta">&gt;&gt;&gt; </span>gb = df.groupby(<span class="hljs-string">'z'</span>)
x y z
<span class="hljs-number">3</span>: a <span class="hljs-number">1</span> <span class="hljs-number">2</span> <span class="hljs-number">3</span>
<span class="hljs-number">6</span>: b <span class="hljs-number">4</span> <span class="hljs-number">5</span> <span class="hljs-number">6</span>
c <span class="hljs-number">7</span> <span class="hljs-number">8</span> <span class="hljs-number">6</span>
</code></pre></div>
<pre><code class="python language-python hljs">&lt;GB&gt; = &lt;DF&gt;.groupby(column_key/s) <span class="hljs-comment"># DF is split into groups based on passed column.</span>
&lt;DF&gt; = &lt;GB&gt;.get_group(group_key) <span class="hljs-comment"># Selects a group by value of grouping column.</span>
&lt;DF&gt; = &lt;GB&gt;.&lt;operation&gt;() <span class="hljs-comment"># Executes operation on each col of each group.</span>
</code></pre>
<div><h3 id="rolling">Rolling</h3><pre><code class="python language-python hljs">&lt;Rl&gt; = &lt;Sr/DF/GB&gt;.rolling(window_size) <span class="hljs-comment"># Also: `min_periods, center=False`.</span>
&lt;Rl&gt; = &lt;Rl&gt;[column_key/s] <span class="hljs-comment"># Or: &lt;Rl&gt;.column_key</span>
&lt;Sr/DF&gt; = &lt;Rl&gt;.sum/max/mean()
&lt;Sr/DF&gt; = &lt;Rl&gt;.apply(&lt;func&gt;) <span class="hljs-comment"># Invokes function on every window.</span>
&lt;Sr/DF&gt; = &lt;Rl&gt;.aggregate(&lt;func&gt;) <span class="hljs-comment"># Invokes function on every window.</span>
<ul>
<li><strong>Result of an operation is a dataframe with index made up of group keys. Use <code class="python hljs"><span class="hljs-string">'&lt;DF&gt;.reset_index()'</span></code> to move the index back into it's own column.</strong></li>
</ul>
<div><h4 id="operations-2">Operations:</h4><pre><code class="python language-python hljs">&lt;DF&gt; = &lt;GB&gt;.sum/max/mean/idxmax/all()
&lt;DF&gt; = &lt;GB&gt;.diff/cumsum/rank() <span class="hljs-comment"># …/pct_change/fillna/ffill()</span>
&lt;DF&gt; = &lt;GB&gt;.apply/agg/transform(&lt;agg_func&gt;)
&lt;DF&gt; = &lt;GB&gt;.agg/transform(&lt;trans_func&gt;)
</code></pre></div>
<pre><code class="python language-python hljs">+-------------+------------+-----------+--------------+--------+-------------+---------------+
| | <span class="hljs-string">'sum'</span> | [<span class="hljs-string">'sum'</span>] | {<span class="hljs-string">'x'</span>: <span class="hljs-string">'sum'</span>} | <span class="hljs-string">'rank'</span> | [<span class="hljs-string">'rank'</span>] | {<span class="hljs-string">'x'</span>: <span class="hljs-string">'rank'</span>} |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.apply(…) | x y z | | | | | |
| | z | | | | | |
| | <span class="hljs-number">3</span> <span class="hljs-number">1</span> <span class="hljs-number">2</span> <span class="hljs-number">3</span> | | | | | |
| | <span class="hljs-number">6</span> <span class="hljs-number">11</span> <span class="hljs-number">13</span> <span class="hljs-number">12</span> | | | | | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.agg(…) | x y | x y | x | x y | x y | x |
| | z | sum sum | z | a <span class="hljs-number">1</span> <span class="hljs-number">1</span> | rank rank | a <span class="hljs-number">1</span> |
| | <span class="hljs-number">3</span> <span class="hljs-number">1</span> <span class="hljs-number">2</span> | z | <span class="hljs-number">3</span> <span class="hljs-number">1</span> | b <span class="hljs-number">1</span> <span class="hljs-number">1</span> | a <span class="hljs-number">1</span> <span class="hljs-number">1</span> | b <span class="hljs-number">1</span> |
| | <span class="hljs-number">6</span> <span class="hljs-number">11</span> <span class="hljs-number">13</span> | <span class="hljs-number">3</span> <span class="hljs-number">1</span> <span class="hljs-number">2</span> | <span class="hljs-number">6</span> <span class="hljs-number">11</span> | c <span class="hljs-number">2</span> <span class="hljs-number">2</span> | b <span class="hljs-number">1</span> <span class="hljs-number">1</span> | c <span class="hljs-number">2</span> |
| | | <span class="hljs-number">6</span> <span class="hljs-number">11</span> <span class="hljs-number">13</span> | | | c <span class="hljs-number">2</span> <span class="hljs-number">2</span> | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
| gb.trans(…) | x y | | | x y | | |
| | a <span class="hljs-number">1</span> <span class="hljs-number">2</span> | | | a <span class="hljs-number">1</span> <span class="hljs-number">1</span> | | |
| | b <span class="hljs-number">11</span> <span class="hljs-number">13</span> | | | b <span class="hljs-number">1</span> <span class="hljs-number">1</span> | | |
| | c <span class="hljs-number">11</span> <span class="hljs-number">13</span> | | | c <span class="hljs-number">1</span> <span class="hljs-number">1</span> | | |
+-------------+------------+-----------+--------------+--------+-------------+---------------+
</code></pre>
<div><h3 id="rolling">Rolling</h3><pre><code class="python language-python hljs">&lt;Rl_S/D/G&gt; = &lt;Sr/DF/GB&gt;.rolling(window_size) <span class="hljs-comment"># Also: `min_periods=None, center=False`.</span>
&lt;Rl_S/D&gt; = &lt;Rl_D/G&gt;[column_key/s] <span class="hljs-comment"># Or: &lt;Rl&gt;.column_key</span>
&lt;Sr/DF/DF&gt; = &lt;Rl_S/D/G&gt;.sum/max/mean()
&lt;Sr/DF/DF&gt; = &lt;Rl_S/D/G&gt;.apply(&lt;func&gt;) <span class="hljs-comment"># Invokes function on every window.</span>
&lt;Sr/DF/DF&gt; = &lt;Rl_S/D/G&gt;.aggregate(&lt;func/str&gt;) <span class="hljs-comment"># Invokes function on every window.</span>
</code></pre></div>
<div><h3 id="encode-2">Encode</h3><pre><code class="python language-python hljs">&lt;DF&gt; = pd.read_json/html(<span class="hljs-string">'&lt;str/path/url&gt;'</span>)
@ -2837,7 +2887,7 @@ plotly.express.line(summed, x=<span class="hljs-string">'Date'</span>, y=<span c
out = pandas.concat([covid, dow_jones, gold, bitcoin], axis=<span class="hljs-number">1</span>)
out = out.loc[<span class="hljs-string">'2020-02-23'</span>:].iloc[:<span class="hljs-number">-2</span>]
out = out.interpolate()
out.iloc[:, <span class="hljs-number">1</span>:] = out.rolling(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>, center=<span class="hljs-keyword">True</span>).mean().iloc[:, <span class="hljs-number">1</span>:]
out.iloc[:, <span class="hljs-number">1</span>:] = out.rolling(<span class="hljs-number">10</span>, min_periods=<span class="hljs-number">1</span>, center=<span class="hljs-keyword">True</span>).mean().iloc[:, <span class="hljs-number">1</span>:]
out.iloc[:, <span class="hljs-number">1</span>:] = out.iloc[:, <span class="hljs-number">1</span>:] / out.iloc[<span class="hljs-number">0</span>, <span class="hljs-number">1</span>:] * <span class="hljs-number">100</span>
<span class="hljs-keyword">return</span> out

Write Preview
Loading…
Cancel
Save