Pandas使用(四)

离散化

离散化是把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。可以简单理解为离散化就是将连续值进行分区间。采用pd.cut()方法。

• pd.cut(x,bins)

  • x : 要进行分组的数据
  • bins : 指定是分组

• pd.value_counts(value)

  • values : 数据
  • 计算数据出现的数据

# @Time : 2020/5/16 13:24 
# @Author : SmallJ 
from numpy import ndarray
import pandas as pd
import numpy as np

# age_number = np.random.randint(10, 60, size=20)
# print(age_number)
# 分组的数据
age_number = [20, 56, 14, 39, 46, 35, 15, 15, 46, 19, 58, 10, 46, 59, 18, 30, 13, 35, 22, 42]

# 要进行的分组
age_bins = [10, 20, 30, 40, 50, 60]

# 离散化
# x: 要进行分组的数据
# bins : 分组
"""
打印出来的结果为:
数据:[20, 56, 14, 39, 46, 35, 15, 15, 46, 19, 58, 10, 46, 59, 18, 30, 13, 35, 22, 42]

[(10, 20], (50, 60], (10, 20], (30, 40], (40, 50], ..., (20, 30], (10, 20], (30, 40], (20, 30], (40, 50]]
Length: 20
Categories (5, interval[int64]): [(10, 20] < (20, 30] < (30, 40] < (40, 50] < (50, 60]]

解释
length : 为20个数据
Categories : 分为5组数据为int64类型
对应的第一个数据为20, 20对应为10到20的区间
对应的第二个数据为56，56对应为50到60的区间，以此类推

"""


data = pd.cut(age_number, bins=age_bins)

# print(data)


data_count= pd.value_counts(data)
# print(data_count)

# value_counts 为查看对应数据的个数
"""
(10, 20]    7
(40, 50]    4
(50, 60]    3
(30, 40]    3
(20, 30]    2
dtype: int64
"""

# 返回相对应是索引的个数
# 返回数据对应数据区间的索引位置
# print(data.codes)

# IntervalIndex : 分组的情况
# closed : 闭合区间指定右边
# dtype : 类型
print(data.categories)

计算虚拟变量

将分类变量转换为 “虚拟” 或 “指标” 或 “指标” 矩阵是另一种用于统计建模或机器学习的转变操作。如果DataFrame中的一列有k个不同的值，则可以衍生一个k列的值为1和0的矩阵或DataFrame。采用pd.get_dummped(data, prefix=None)

• pd.get_dummped(data,prefix)
  • data : 指定的数据
  • prefix : 标签

# @Time : 2020/5/16 14:30 
# @Author : SmallJ 

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 创建数组
df = pd.DataFrame({
    'key': ['b', 'b', 'a', 'c', 'a', 'b'],
    'data': range(6)
})


# data : 要传入的数据
data = pd.get_dummies(df, prefix='demo')

""":输出结果
   data  demo_a  demo_b  demo_c
0     0       0       1       0
1     1       0       1       0
2     2       1       0       0
3     3       0       0       1
4     4       1       0       0
5     5       0       1       0

# 为什么为demo_a,demo_b.demo_c 呢？
由于我给了参数prefix为自定义参数
然后传入的数据集中最多为abc就没数据了,所以只有abc

data为数据
get_dummies这个函数就会在数据集中进行操作
有的情况下为1

"""

print(data)

5-4 数据规整与分组

数据合并

• df_l.join(df_r)
  • 默认情况下是把行索引相同的数据合并到一起

In [4]: import pandas as pd

In [5]: import numpy as np

In [6]: df1 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'), columns=list('abcd'))

In [7]: df2 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('def'), columns=list('wxyz'))

In [8]: df1
Out[8]:
   a  b   c   d
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

In [9]: df2
Out[9]:
   w  x   y   z
d  0  1   2   3
e  4  5   6   7
f  8  9  10  11

# 当对应的df2没有对应的索引的时候，将补齐为nan
In [10]: df1.join(df2)
Out[10]:
   a  b   c   d   w   x   y   z
a  0  1   2   3 NaN NaN NaN NaN
b  4  5   6   7 NaN NaN NaN NaN
c  8  9  10  11 NaN NaN NaN NaN

In [11]: # 默认情况下是把行索引相同的数据进行合并
# join方法默认采用行索引相同的情况下进行拼接数据
# 例如:df1.join(df2) 采用的是df1的行索引
# 谁在前面就调用谁的行索引
        

In [12]: df2.join(df1)
Out[12]:
   w  x   y   z   a   b   c   d
d  0  1   2   3 NaN NaN NaN NaN
e  4  5   6   7 NaN NaN NaN NaN
f  8  9  10  11 NaN NaN NaN NaN

In [13]: df2 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'), columns=list('wxyz'))

In [14]: df1
Out[14]:
   a  b   c   d
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

In [15]: df2
Out[15]:
   w  x   y   z
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

# 当对应的行索引相加出的结果
In [16]: df1.join(df2)
Out[16]:
   a  b   c   d  w  x   y   z
a  0  1   2   3  0  1   2   3
b  4  5   6   7  4  5   6   7
c  8  9  10  11  8  9  10  11

# 当指定df2也采用相同的列索引的时候拼接时
In [17]: df2 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'), columns=list('abcd'))

In [18]: df1
Out[18]:
   a  b   c   d
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

In [19]: df2
Out[19]:
   a  b   c   d
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

# 会报出列重叠的错误
In [20]: df1.join(df2)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-20-f8069890b6d0> in <module>
----> 1 df1.join(df2)

d:\python3.6.5\lib\site-packages\pandas\core\frame.py in join(self, other, on, how, lsuffix, rsuffix, sort)
   7259         # For SparseDataFrame's benefit
   7260         return self._join_compat(
-> 7261             other, on=on, how=how, lsuffix=lsuffix, rsuffix=rsuffix, sort=sort
   7262         )
   7263

d:\python3.6.5\lib\site-packages\pandas\core\frame.py in _join_compat(self, other, on, how, lsuffix, rsuffix, sort)
   7282                 right_index=True,
   7283                 suffixes=(lsuffix, rsuffix),
-> 7284                 sort=sort,
   7285             )
   7286         else:

d:\python3.6.5\lib\site-packages\pandas\core\reshape\merge.py in merge(left, right, how, on, left_on, right_on, left_index, right_index, sort, suffixes, copy, indicator, validate)
     81         validate=validate,
     82     )
---> 83     return op.get_result()
     84
     85

d:\python3.6.5\lib\site-packages\pandas\core\reshape\merge.py in get_result(self)
    646
    647         llabels, rlabels = _items_overlap_with_suffix(
--> 648             ldata.items, lsuf, rdata.items, rsuf
    649         )
    650

d:\python3.6.5\lib\site-packages\pandas\core\reshape\merge.py in _items_overlap_with_suffix(left, lsuffix, right, rsuffix)
   2009         raise ValueError(
   2010             "columns overlap but no suffix specified: "
-> 2011             "{rename}".format(rename=to_rename)
   2012         )
   2013

ValueError: columns overlap but no suffix specified: Index(['a', 'b', 'c', 'd'], dtype='object')

• pd.merge(df_l,df_r)

  • 按照指定的列把数据按照一定的方式合并到一起
  • how : 指定拼接方式,默认情况下为inner
  • on : 需要连接的列名 。注意： 必须是公共列
  • left_on : 左边数组中用作连接的列
  • right_on : 右边数组中用连接的列

当有公共元素的时候

• 当有公共 元素的时候将会显示公共元素的值

import pandas as pd
import numpy as np


# merge
# 按照指定的列吧数据按照一定的方式合并到一起
# how : 指定的拼接方式,默认情况下为inner


df3 = pd.DataFrame(np.arange(6).reshape(2, 3), index=list('ab'), columns=list('xyz'))
df4 = pd.DataFrame(np.arange(6).reshape(3, 2), index=list('abc'), columns=list('wz'))


# 必须传入的两个参数
# left
# right
"""
   x  y  z
a  0  1  2
b  3  4  5
------------------------------
   w  z
a  0  1
b  2  3
c  4  5
------------------------------
   x  y  z  w
0  3  4  5  4

输出结果为什么会为 345呢
因为该函数是以公共列中的公共元素进行拼接
在df3和df4中
出现了公共列为z,然后又出现了公共的元素为5
所以便采用了df3的b行和bf4的c行
"""

data = pd.merge(df3, df4)
print(df3)
print('-'*30)
print(df4)
print('-'*30)
print(data)

当没有公共元素的时候

• 当没有公共元素的时候不会报错，但拼接结果为空

import pandas as pd
import numpy as np

df3 = pd.DataFrame(np.arange(6).reshape(2, 3), index=list('ab'), columns=list('xyz'))
df4 = pd.DataFrame(np.arange(6).reshape(3, 2), index=list('abc'), columns=list('wz'))



print(df3)
print('-'*30)


# 修改df4的公共值
df4.loc['c', 'z'] = 6
print(df4)
print('-'*30)

data = pd.merge(df3, df4)
print(data)

"""
   x  y  z
a  0  1  2
b  3  4  5
------------------------------
   w  z
a  0  1
b  2  3
c  4  6
------------------------------
Empty DataFrame
Columns: [x, y, z, w]
Index: []
"""

当有多个公共元素的时候

# 当有多个公共元素的时候
import pandas as pd
import numpy as np

df3 = pd.DataFrame(np.arange(6).reshape(2, 3), index=list('ab'), columns=list('xyz'))
df4 = pd.DataFrame(np.arange(6).reshape(3, 2), index=list('abc'), columns=list('wz'))

print(df3)

print('-'*30)

# 修该多个公共元素
df4.loc['a':'b', 'z'] = [2, 5]
print(df4)

print('-'*30)

data = pd.merge(df3, df4)
print(data)


"""
df3
   x  y  z
a  0  1  2
b  3  4  5
------------------------------
df4
   w  z
a  0  2
b  2  5
c  4  5
------------------------------
   x  y  z  w
0  0  1  2  0   # 这一行的数据生成解释: 因为df3和df4 z列中存在着公共的值为2 ,所以将采用 x:0, y:1, z:2, w:0, z:2
1  3  4  5  2   # 这一行的数据生成解释: 因为df3和df4 z列中存在着公共的值为5 ,所以将采用 x:3, y:4, z:5, w:2, z:5
2  3  4  5  4   # 这一行的数据生成解释: 因为df3和df4 z列中存在着公共的值为5 ,所以将采用 x:3, y:4, z:5, w:4, z:5
"""

数据分组与聚合

数据包含在Series、DataFrame数据结构中，可以根据一个或多个键分离到各个组中。分组操作之后，一个函数就可以应用到各个组中，产生新的值。如下图则是简单的分组聚合过程

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: data = {     "key1": ['a', 'a', 'b', 'b', 'a'],     "key2": ['one', "two", "one", "two",
   ...:  "one"],     "data1": np.arange(5),     "data2": np.arange(5) }

In [4]: pd.DataFrame(data)
Out[4]:
  key1 key2  data1  data2
0    a  one      0      0
1    a  two      1      1
2    b  one      2      2
3    b  two      3      3
4    a  one      4      4

In [5]: df = pd.DataFrame(data)

In [6]: df
Out[6]:
  key1 key2  data1  data2
0    a  one      0      0
1    a  two      1      1
2    b  one      2      2
3    b  two      3      3
4    a  one      4      4

In [7]: # 当采用groupby进行分组操作的时候并不会进行其他操作

In [8]: keys = df.groupby('key1')

In [9]: keys
Out[9]: <pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001AAF27CF1D0>

In [10]: # 打印出来的结果为对象值

In [11]: for key in keys:
    ...:     print(key)
    ...:
('a',   key1 key2  data1  data2
0    a  one      0      0
1    a  two      1      1
4    a  one      4      4)
('b',   key1 key2  data1  data2
2    b  one      2      2
3    b  two      3      3)

In [12]: # 将进行key1求和操作

In [13]: keys.sum()
Out[13]:
      data1  data2
key1
a         5      5
b         5      5