# 
df['Test_1'] = df['Test_0'] - 1
>
	Area	Bins	Test_0	Data	Test_1
0	A	110	0	0.632955	-1
1	A	110	1	1.485463	0
2	A	160	0	-1.193891	-1
3	A	160	1	-0.324484	0
4	A	160	2	1.293263	1
5	C	40	0	-0.476979	-1
6	C	40	1	-0.467655	0

####Combine by value-based condition:clipboard:
The code below is stackoverflow.I have changed some code from the post on com.

```python
import operator as op

df_a = pd.DataFrame([{"a": 1, "b": 4}, {"a": 2, "b": 5}, {"a": 3, "b": 6}])
df_b = pd.DataFrame([{"c": 2, "d": 7}, {"c": 3, "d": 8}])

binOp   = op.lt
matches = np.where(binOp(df_a.a[:,None],df_b.c.values))

pd.concat([df.ix[idxs].reset_index(drop=True) 
                 for df,idxs in zip([df_a,df_b],matches)], axis=1)
df_a
	a	b
0	1	4
1	2	5
2	3	6
df_b

	c	d
0	2	7
1	3	8
# result
	a	b	c	d
0	1	4	2	7
1	1	4	3	8
2	2	5	3	8

[Code reading]

*FirstmachtesWhen disassembling

# Check the contents of columns df.a and df.b
df_a.a[:,None]
array([[1],
       [2],
       [3]])
df_b.c.values
array([2, 3])

*Function-style standard operatoroperator.lt(a,b)Isa < bso,a < bIs equivalent to

op.lt(df_a.a[:,None],df_b.c.values)
array([[ True,  True],
       [False,  True],
       [False, False]])
# I could write it like this if it was written differently
df_a.a[:,None] < df_b.c.values
array([[ True,  True],
       [False,  True],
       [False, False]])
>
# To check this content
df_a.a[:,None][0] < df_b.c.values[0]
array([ True])
df_a.a[:,None][0] < df_b.c.values[1]
array([ True])
df_a.a[:,None][1] < df_b.c.values[0]
array([False])
df_a.a[:,None][1] < df_b.c.values[1]
array([ True])
df_a.a[:,None][2] < df_b.c.values[0]
array([False])
df_a.a[:,None][2] < df_b.c.values[1]
array([False])
>
# In the case of np.where (condition), the index of the element that satisfies the condition is returned in tuple format.
np.where([[True, True], [False, True], [False, False]])
(array([0, 0, 1]), array([0, 1, 1]))
>
# Extract with the conditions obtained in'matches' earlier.
[df.loc[idxs].reset_index(drop=True) for df,idxs in zip([df_a,df_b],matches)]
[   a  b
 0  1  4
 1  1  4
 2  2  5,    c  d
 0  2  7
 1  3  8
 2  3  8]
>
# This is connected in the horizontal direction (axis = 1).
	a	b	c	d
0	1	4	2	7
1	1	4	3	8
2	2	5	3	8

Plotting(Drawing)

n [186]: df = pd.DataFrame(
   .....:     {'stratifying_var': np.random.uniform(0, 100, 20),
   .....:      'price': np.random.normal(100, 5, 20)})
   .....: 

In [187]: df['quartiles'] = pd.qcut(
   .....:     df['stratifying_var'],
   .....:     4,
   .....:     labels=['0-25%', '25-50%', '50-75%', '75-100%'])
   .....: 

In [188]: df.boxplot(column='price', by='quartiles')
Out[188]: <matplotlib.axes._subplots.AxesSubplot at 0x7fc66b7f1710>

[Code reading]

 pandas.qcut(x, q, labels=None...)
# Divide x by the number of q: bin divisions and add labels.
df['quartiles'] = pd.qcut(df['stratifying_var'], 4, labels=['0-25%', '25-50%', '50-75%', '75-100%'])
>
	stratifying_var	price	quartiles
0	95.463259	110.468740	75-100%
1	61.567537	105.038334	50-75%
2	93.169189	99.502664	75-100%
3	32.881181	100.462400	25-50%
4	22.735506	95.821731	0-25%
5	85.662861	101.262124	75-100%
6	24.251856	102.351950	0-25%
7	26.323525	91.812003	25-50%
8	6.192982	111.425087	0-25%
9	25.520758	104.666583	25-50%
10	75.505473	104.450480	75-100%
11	30.620504	100.044772	25-50%
12	40.438555	102.697402	50-75%
13	18.171318	102.612876	0-25%
14	57.080747	101.067847	50-75%
15	44.066472	93.410125	50-75%
16	64.131972	103.707151	50-75%
17	33.548572	103.359709	25-50%
18	88.433754	99.416668	75-100%
19	21.660715	91.229785	0-25%

Data IN/Out(Data input / output)

###Read multiple files to create a single DataFrame:thumbsup:

# Example A
n [189]: for i in range(3):
             data = pd.DataFrame(np.random.randn(10, 4))
             data.to_csv('file_{}.csv'.format(i))

In [190]: files = ['file_0.csv', 'file_1.csv', 'file_2.csv']
In [191]: result = pd.concat([pd.read_csv(f) for f in files], ignore_index=True)

# Example B
In [192]: import glob
In [193]: import os

In [194]: files = glob.glob('file_*.csv')
In [195]: result = pd.concat([pd.read_csv(f) for f in files], ignore_index=True)

[Code reading]

*In example A, a sample file is created in a loop, and the sample file is read and combined. *In example B, the created file name is read by the glob function, and the file is read and combined.

###Parsing multi-column date components

In [196]: i = pd.date_range('20000101', periods=10000)

In [197]: df = pd.DataFrame({'year': i.year, 'month': i.month, 'day': i.day})

In [198]: df.head()
Out[198]: 
   year  month  day
0  2000      1    1
1  2000      1    2
2  2000      1    3
3  2000      1    4
4  2000      1    5

In [199]: %timeit pd.to_datetime(df.year * 10000 + df.month * 100 + df.day, format='%Y%m%d')
 ds = df.apply(lambda x: "%04d%02d%02d" % (x['year'],
                                          x['month'], x['day']), axis=1)
ds.head()
 %timeit pd.to_datetime(ds)

9.98 ms +- 235 us per loop (mean +- std. dev. of 7 runs, 100 loops each)
2.91 ms +- 57.5 us per loop (mean +- std. dev. of 7 runs, 100 loops each)

[Code reading]

# When calculating and creating time series information using the values of the created data frame
df.year * 10000 + df.month * 100 + df.day
>
# When creating time series information with a function from the elements of the created data frame
 ds = df.apply(lambda x: "%04d%02d%02d" % (x['year'], x['month'], x['day']), axis=1)

Difference in calculation cost?

###Skip the line between the header and the data

In [200]: data = """;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
        ;;;;
         date;Param1;Param2;Param4;Param5
             ;m²;°C;m²;m
        ;;;;
         01.01.1990 00:00;1;1;2;3
         01.01.1990 01:00;5;3;4;5
         01.01.1990 02:00;9;5;6;7
         01.01.1990 03:00;13;7;8;9
         01.01.1990 04:00;17;9;10;11
         01.01.1990 05:00;21;11;12;13
 """

Option 1:Explicitly pass a line and skip the line

In [201]: from io import StringIO

In [202]: pd.read_csv(StringIO(data), sep=';', skiprows=[11, 12],

Out[202]: 
                     Param1  Param2  Param4  Param5
date                                               
1990-01-01 00:00:00       1       1       2       3
1990-01-01 01:00:00       5       3       4       5
1990-01-01 02:00:00       9       5       6       7
1990-01-01 03:00:00      13       7       8       9
1990-01-01 04:00:00      17       9      10      11
1990-01-01 05:00:00      21      11      12      13

Option 2:Read column names and then read data

In [203]: pd.read_csv(StringIO(data), sep=';', header=10, nrows=10).columns
Out[203]: Index(['date', 'Param1', 'Param2', 'Param4', 'Param5'], dtype='object')

In [204]: columns = pd.read_csv(StringIO(data), sep=';', header=10, nrows=10).columns

In [205]: pd.read_csv(StringIO(data), sep=';', index_col=0,
                      header=12, parse_dates=True, names=columns)

Out[205]: 
                     Param1  Param2  Param4  Param5
date                                               
1990-01-01 00:00:00       1       1       2       3
1990-01-01 01:00:00       5       3       4       5
1990-01-01 02:00:00       9       5       6       7
1990-01-01 03:00:00      13       7       8       9
1990-01-01 04:00:00      17       9      10      11
1990-01-01 05:00:00      21      11      12      13

[Code reading]

I think that either one is not advantageous regardless of the size of the data. In any case, it is necessary to find the number of lines to skip and the line corresponding to the header line, so you need to skip the appropriate number of lines and open it, or open it separately with an editor first.

#Computation) ###correlation

In [211]: df = pd.DataFrame(np.random.random(size=(100, 5)))

In [212]: corr_mat = df.corr()

In [213]: mask = np.tril(np.ones_like(corr_mat, dtype=np.bool), k=-1)

In [214]: corr_mat.where(mask)
Out[214]: 
          0         1         2         3   4
0       NaN       NaN       NaN       NaN NaN
1 -0.018923       NaN       NaN       NaN NaN
2 -0.076296 -0.012464       NaN       NaN NaN
3 -0.169941 -0.289416  0.076462       NaN NaN
4  0.064326  0.018759 -0.084140 -0.079859 NaN

[Code reading]

mask
array([[False, False, False, False, False],
       [ True, False, False, False, False],
       [ True,  True, False, False, False],
       [ True,  True,  True, False, False],
       [ True,  True,  True,  True, False]])
>
mask2 = np.triu(np.ones_like(corr_mat, dtype=np.bool), k=-1)
mask2
array([[ True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True],
       [False,  True,  True,  True,  True],
       [False, False,  True,  True,  True],
       [False, False, False,  True,  True]])
>
corr_mat.where(mask2)
>
0	1	2	3	4
0	1.000000	-0.022615	0.047486	0.092043	-0.112379
1	-0.022615	1.000000	-0.336864	-0.025473	0.004696
2	NaN			-0.336864	1.000000	0.047746	-0.008458
3	NaN			NaN			0.047746	1.000000	0.133289
4	NaN			NaN			NaN			0.133289	1.000000

numpy.tril() ->Extract the lower triangular matrix from the Numpy array(Lower triangle of an array.) numpy.triu() ->Extract the upper triangular matrix from the Numpy array(Upper triangle of an array.)

Timedeltas(elapsed time)

In [218]: import datetime

In [219]: s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))

In [220]: s - s.max()
Out[220]: 
0   -2 days
1   -1 days
2    0 days
dtype: timedelta64[ns]

In [221]: s.max() - s
Out[221]: 
0   2 days
1   1 days
2   0 days
dtype: timedelta64[ns]

In [222]: s - datetime.datetime(2011, 1, 1, 3, 5)
Out[222]: 
0   364 days 20:55:00
1   365 days 20:55:00
2   366 days 20:55:00
dtype: timedelta64[ns]

In [223]: s + datetime.timedelta(minutes=5)
Out[223]: 
0   2012-01-01 00:05:00
1   2012-01-02 00:05:00
2   2012-01-03 00:05:00
dtype: datetime64[ns]

In [224]: datetime.datetime(2011, 1, 1, 3, 5) - s
Out[224]: 
0   -365 days +03:05:00
1   -366 days +03:05:00
2   -367 days +03:05:00
dtype: timedelta64[ns]

In [225]: datetime.timedelta(minutes=5) + s
Out[225]: 
0   2012-01-01 00:05:00
1   2012-01-02 00:05:00
2   2012-01-03 00:05:00
dtype: datetime64[ns]

[Code reading]

# 2 weeks later
s + datetime.timedelta(weeks=2)
>
0   2012-01-15
1   2012-01-16
2   2012-01-17
dtype: datetime64[ns]
# 2 weeks ago
s + datetime.timedelta(weeks=-2)
>
0   2011-12-18
1   2011-12-19
2   2011-12-20
dtype: datetime64[ns]

###Addition and subtraction of elapsed time and date

In [226]: deltas = pd.Series([datetime.timedelta(days=i) for i in range(3)])

In [227]: df = pd.DataFrame({'A': s, 'B': deltas})

In [228]: df
Out[228]: 
           A      B
0 2012-01-01 0 days
1 2012-01-02 1 days
2 2012-01-03 2 days

In [229]: df['New Dates'] = df['A'] + df['B']

In [230]: df['Delta'] = df['A'] - df['New Dates']

In [231]: df
Out[231]: 
           A      B  New Dates   Delta
0 2012-01-01 0 days 2012-01-01  0 days
1 2012-01-02 1 days 2012-01-03 -1 days
2 2012-01-03 2 days 2012-01-05 -2 days

In [232]: df.dtypes
Out[232]: 
A             datetime64[ns]
B            timedelta64[ns]
New Dates     datetime64[ns]
Delta        timedelta64[ns]
dtype: object

[Code reading]

# Perform weekly addition
w_deltas = pd.Series([datetime.timedelta(weeks=i) for i in range(3)])
w_deltas
0    0 days
1    7 days
2   14 days
dtype: timedelta64[ns]
>
df['W_Delta'] = df['A'] + w_deltas
>
A	B	New Dates	Delta	W_Delta
0	2012-01-01	0 days	2012-01-01	0 days	2012-01-01
1	2012-01-02	1 days	2012-01-03	-1 days	2012-01-09
2	2012-01-03	2 days	2012-01-05	-2 days	2012-01-17

#Axis name alias ###To provide axis name aliases globally, you can define two functions:

def set_axis_alias(cls, axis, alias):
    if axis not in cls._AXIS_NUMBERS:
        raise Exception("invalid axis [%s] for alias [%s]" % (axis, alias))
     cls._AXIS_ALIASES[alias] = axis

def clear_axis_alias(cls, axis, alias):
     if axis not in cls._AXIS_NUMBERS:
        raise Exception("invalid axis [%s] for alias [%s]" % (axis, alias))
     cls._AXIS_ALIASES.pop(alias, None)

set_axis_alias(pd.DataFrame, 'columns', 'myaxis2')
df2 = pd.DataFrame(np.random.randn(3, 2), columns=['c1', 'c2'],
                   index=['i1', 'i2', 'i3'])

In [241]: df2.sum(axis='myaxis2')
Out[241]: 
i1   -0.461013
i2    2.040016
i3    0.904681
dtype: float64

In [242]: clear_axis_alias(pd.DataFrame, 'columns', 'myaxis2')

[Code reading]

# An error occurred in df2.sum (axis ='myaxis2').
df2.sum(axis=1)

I think this function can define its own axis name, but in reality an error occurs and no result is obtained.axis=1Was obtained by specifying.

Creating example data(Creating sample data)

In [243]: def expand_grid(data_dict):
              rows = itertools.product(*data_dict.values())
              return pd.DataFrame.from_records(rows, columns=data_dict.keys())

In [244]: df = expand_grid({'height': [60, 70],
                            'weight': [100, 140, 180],
                            'sex': ['Male', 'Female']})

In [245]: df
Out[245]: 
    height  weight     sex
0       60     100    Male
1       60     100  Female
2       60     140    Male
3       60     140  Female
4       60     180    Male
5       60     180  Female
6       70     100    Male
7       70     100  Female
8       70     140    Male
9       70     140  Female
10      70     180    Male
11      70     180  Female

#Creating sample data *To create a data frame from all combinations of a particular value, you can create a dictionary where the key is the column name and the value is a list of data values.

In [243]: def expand_grid(data_dict):
              rows = itertools.product(*data_dict.values())
              return pd.DataFrame.from_records(rows, columns=data_dict.keys())

In [244]: df = expand_grid({'height': [60, 70],
                            'weight': [100, 140, 180],
                            'sex': ['Male', 'Female']})

In [245]: df
Out[245]: 
    height  weight     sex
0       60     100    Male
1       60     100  Female
2       60     140    Male
3       60     140  Female
4       60     180    Male
5       60     180  Female
6       70     100    Male
7       70     100  Female
8       70     140    Male
9       70     140  Female
10      70     180    Male
11      70     180  Female

[Code reading]

# * dict.values () expands dictionary-style values
d_dict = {'height': [60, 70], 'weight': [100, 140, 180], 'sex': ['Male', 'Female']}
print(*d_dict.values())
[60, 70] [100, 140, 180] ['Male', 'Female']
>
# All combinations Cartesian product (Descartes) itertools.product is an iterator
rows = itertools.product(*d_dict.values())
>
for r in rows:
    print(r)
>
(60, 100, 'Male')
(60, 100, 'Female')
(60, 140, 'Male')
(60, 140, 'Female')
(60, 180, 'Male')
(60, 180, 'Female')
(70, 100, 'Male')
(70, 100, 'Female')
(70, 140, 'Male')
(70, 140, 'Female')
(70, 180, 'Male')
(70, 180, 'Female')

#Afterword *Thank you for watching until the end. It's been about two and a half years since I started learning the Python language, and the self-study of the official cookbook was a struggle. *The first time, I started by preparing the same data as the official one, but I gave up because I could not think of sample data on the way. *The second time, I tried to create the code reading part with the folding function by quoting the formula, but I decided that it did not convey the feeling of struggle. Please forgive the part that is not fully explained while the accurate understanding and description of the language are not left. The real feeling after finishing is"The one who controls the index controls the Pandas."**I thought. *For the explanation in code reading, I used mathjax for the first time, but it is unknown whether it worked.