python第二阶段（2）入门-数据科学包 pandas

最新推荐文章于 2024-08-15 01:55:01 发布

DD546250327

最新推荐文章于 2024-08-15 01:55:01 发布

阅读量232

点赞数

文章标签： python

本文链接：https://blog.csdn.net/DD546250327/article/details/108230185

版权

数据科学包 pandas

导入pandas
创建对象
合并，新增，连接和比较

Pandas库是处理时间序列的利器，pandas有着强大的日期数据处理功能，可以按日期筛选数据、按日期显示数据、按日期统计数据

导入pandas

pandas常与numpy库一起使用，所以通常会一起引用，所以也要导入import numpy as np

import numpy as np
import pandas as pd

创建对象

1 系列

使用pandas.Series创建一个传递值的列表,创建一个默认的整数索引。
Series是一维标记的数组，能够保存任何数据类型（整数，字符串，浮点数，Python对象等），轴标签统称为index。创建系列的基本方法是调用：

s = pd.Series(data, index=index)

示例1：

import pandas as pd
import numpy as np
s= pd.Series([1, 3, 5, np.nan, 6, 8])#np.nan为缺失的意思，输出NaN（不是数字）是pandas中使用的标准缺失数据标记
print(s)

执行结果；

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

示例2：

import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
print(s)

执行结果：

a    1.072281
b    1.044089
c    0.513690
d    2.182186
e    2.536055
dtype: float64

2 日期序列（1）

pandas 时间序列之pd.date_range()

pd.date_range(
    start=None,#开始时间
    end=None,#截止时间
    periods=None,#总长度
    freq=None,#时间间隔
    tz=None,#时区
    normalize=False,#是否标准化到midnight
    name=None,#date名称
    closed=None,#首尾是否在内
    **kwargs,
)

使用pandas.DataFrame传递带有日期时间索引和带标签的列的NumPy数组来创建。

import pandas as pd
import numpy as np
dates = pd.date_range('20200825', periods=6) #start=None,#开始时间， periods=None,#总长度
# pd.DataFrame（data,index，columns）函数是创建一个二维表
#第一个参数是存放在DataFrame里的数据，第二个参数index就是行名，第三个参数columns是列名
df = pd.DataFrame(np.random.randn(6, 4),index=dates,columns=list('ABCD'))
print(dates)
print(df)

执行结果：

DatetimeIndex(['2020-08-25', '2020-08-26', '2020-08-27', '2020-08-28',
               '2020-08-29', '2020-08-30'],
              dtype='datetime64[ns]', freq='D')
                   A         B         C         D
2020-08-25  0.092970  1.411804  1.338943 -0.276315
2020-08-26 -0.266851  0.120493 -0.375229 -0.299913
2020-08-27  0.221085 -0.395378  1.255595 -0.871075
2020-08-28 -0.537325  0.946851  0.625718 -0.413437
2020-08-29  0.306549  0.504406  1.831040  0.431523
2020-08-30 -0.672404  0.306092 -1.537665 -0.673312

3 日期序列（2）

DataFrame通过传递可以转换为类似序列的对象的字典来创建。

pd.Series([list],index=[list])
参数为list ,index为可选参数，若不填写则默认为index从0开始

import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 1.,
                    'B': pd.Timestamp('20200825'),#pd.timestamp（时间戳）
                    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype='int32'),
                    'E': pd.Categorical(["test", "train", "test", "train"]),
                    'F': 'foo'})
print(df)

执行结果：

     A          B    C  D      E    F
0  1.0 2020-08-25  1.0  3   test  foo
1  1.0 2020-08-25  1.0  3  train  foo
2  1.0 2020-08-25  1.0  3   test  foo
3  1.0 2020-08-25  1.0  3  train  foo

4 Series的操作（1）

示例

import numpy as np
s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
print("这是输出整个系列：",s)
print("这是输出系列第2个值：",s[2])
print("这是输出系列0到第三个及标签（a,b,c)：",s[:3])
print("这是输出系列第三到最后一个及标签（d,e)：",s[3:])
print("这是输出大于s的中值的值：",s[s > s.median()])
print("这是输出大于e的s次幂：",np.exp(s))

执行结果：

这是输出整个系列： 
a   -0.191486
b   -0.985454
c   -1.951298
d    0.424576
e    0.843122
dtype: float64
这是输出系列第2个值： -1.9512979991173534
这是输出系列0到第三个及标签（a,b,c)： 
a   -0.191486
b   -0.985454
c   -1.951298
dtype: float64
这是输出系列第三到最后一个及标签（d,e)： 
d    0.424576
e    0.843122
dtype: float64
这是输出大于s的中值的值： 
d    0.424576
e    0.843122
dtype: float64
这是输出大于e的s次幂： 
a    0.825731
b    0.373270
c    0.142090
d    1.528942
e    2.323611
dtype: float64

5 Series的操作（2）

可以将Series看成是一个定长的有序字典，如果数据存放在一个python字典中，也可以直接通过这个字典来创建Series。

import pandas as pd
# import numpy as np
sdata = {'Ohio':3500, 'Texas':7100, 'Oregon':1600, 'Utah':5000}
obj3 = pd.Series(sdata)
print(obj3)

执行结果：

Ohio      3500
Texas     7100
Oregon    1600
Utah      5000
dtype: int64

合并，新增，连接和比较

pandas提供了各种功能，可轻松地将Series或DataFrame与各种用于索引和关系代数功能的集合逻辑组合在一起。

1 连接

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None,
          levels=None, names=None, verify_integrity=False, copy=True)

objs：Series或DataFrame对象的序列或映射。如果传递了dict ，则除非传递了已排序的键，否则它将用作keys参数，在这种情况下，将选择值（请参见下文）。除非所有对象都为None，否则所有None对象都将被静默删除，在这种情况下将引发ValueError。

axis ：{0，1，…}，默认值为0。要沿其连接的轴。

join：{‘inner’，‘outer’}，默认为’outer’。如何处理其他轴上的索引。外部为联合，内部为交叉。

ignore_index：布尔值，默认为False。如果为True，则不要在串联轴上使用索引值。结果轴将标记为0，…，n-1。如果要串联对象时，串联轴没有有意义的索引信息，这将很有用。请注意，联接中仍会考虑其他轴上的索引值。

keys：序列，默认为无。使用传递的键作为最外层级别来构造层次结构索引。如果通过了多个级别，则应包含元组。

levels：序列列表，默认为无。用于构造MultiIndex的特定级别（唯一值）。否则，将从按键推断出它们。

names：列表，默认为无。生成的层次结构索引中的级别的名称。

verify_integrity：布尔值，默认为False。检查新的串联轴是否包含重复项。相对于实际数据串联而言，这可能非常昂贵。

copy：布尔值，默认为True。如果为False，则不要不必要地复制数据。

import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']},
                    index=[0, 1, 2, 3])

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']},
                    index=[4, 5, 6, 7])


df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                    'B': ['B8', 'B9', 'B10', 'B11'],
                    'C': ['C8', 'C9', 'C10', 'C11'],
                    'D': ['D8', 'D9', 'D10', 'D11']},
                    index=[8, 9, 10, 11])
frames = [df1, df2, df3]
result = pd.concat(frames)
frames = [df1, df2, df3]
result = pd.concat(frames)
print("简单粗暴的结果：")
print(frames)
print("用concat()函数的结果：")
print(result)

执行结果：

简单粗暴的结果：
[    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3,     A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7,       A    B    C    D
8    A8   B8   C8   D8
9    A9   B9   C9   D9
10  A10  B10  C10  D10
11  A11  B11  C11  D11]
用concat()函数的结果：
      A    B    C    D
0    A0   B0   C0   D0
1    A1   B1   C1   D1
2    A2   B2   C2   D2
3    A3   B3   C3   D3
4    A4   B4   C4   D4
5    A5   B5   C5   D5
6    A6   B6   C6   D6
7    A7   B7   C7   D7
8    A8   B8   C8   D8
9    A9   B9   C9   D9
10  A10  B10  C10  D10
11  A11  B11  C11  D11

2 append()增加

import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']},
                    index=[0, 1, 2, 3])

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']},
                    index=[4, 5, 6, 7])
result = df1.append(df2)
print("用append()函数添加的结果：")
print(result)

执行结果：

用append()函数添加的结果：
    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

3 merge()

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True,
         suffixes=('_x', '_y'), copy=True, indicator=False,
         validate=None)

left：一个DataFrame或命名为Series的对象。

right：另一个DataFrame或命名为Series的对象。

on：要加入的列或索引级别名称。必须在左右DataFrame和/或Series对象中找到。如果没有通过，left_index并且 right_index是False在DataFrames和/或系列列的交叉点会被推断为联接键。

left_on：左侧DataFrame或Series中的列或索引级别用作键。可以是列名称，索引级别名称，也可以是长度等于DataFrame或Series长度的数组。

right_on：右侧DataFrame或Series中的列或索引级别用作键。可以是列名称，索引级别名称，也可以是长度等于DataFrame或Series长度的数组。

left_index：如果为True，则使用左侧DataFrame或Series中的索引（行标签）作为其连接键。对于具有MultiIndex（分层结构）的DataFrame或Series，级别数必须与正确的DataFrame或Series中的联接键数匹配。

right_index：与left_index正确的DataFrame或Series的用法相同

how：其一’left’，‘right’，‘outer’，‘inner’。默认为inner。有关每种方法的详细说明，请参见下文。

sort：按字典顺序按连接键对结果DataFrame进行排序。默认为True，设置为False可以在许多情况下显着提高性能。

suffixes：适用于重叠列的字符串后缀元组。默认为。(’_x’, ‘_y’)

copy注意：始终True从传递的DataFrame或命名的Series对象复制数据（默认），即使不需要重新索引也是如此。在很多情况下都无法避免，但是可以提高性能/内存使用率。可以避免复制的情况有些病态，但是仍然提供了此选项。

indicator：将一列添加到输出DataFrame中_merge ，并在每一行的源上提供信息。_merge是分类型和呈现的价值left_only的意见，其合并键只出现在’left’数据帧或系列，right_only为观察其合并键只出现在’right’数据帧或系列，并且both如果关注的重点合并中都发现。

import pandas as pd
# import numpy as np
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

result = pd.merge(left, right, on=['key1', 'key2'])
print("用merge()函数的结果：")
print(result)

用merge()函数的结果：
  key1 key2   A   B   C   D
0   K0   K0  A0  B0  C0  D0
1   K0   K1  A1  B1  C1  D1
2   K1   K0  A2  B2  C2  D2
3   K2   K1  A3  B3  C3  D3

4 join()

left.join(right, on=key_or_keys)

示例：

import pandas as pd
import numpy as np
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                     'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
                    'D': ['D0', 'D1']},
                     index=['K0', 'K1'])

result = left.join(right, on='key')
print("用join()函数的结果：")
print(result)

用join()函数的结果：
    A   B key   C   D
0  A0  B0  K0  C0  D0
1  A1  B1  K1  C1  D1
2  A2  B2  K0  C0  D0
3  A3  B3  K1  C1  D1

DD546250327

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python第二阶段（2）入门-数据科学包 pandas

数据科学包 pandas导入pandas创建对象1 系列2 日期序列（1）3 日期序列（2）4 Series的操作（1）5 Series的操作（2）合并，新增，连接和比较1 连接2 append()增加3 merge()4 join()Pandas库是处理时间序列的利器，pandas有着强大的日期数据处理功能，可以按日期筛选数据、按日期显示数据、按日期统计数据导入pandaspandas常与numpy库一起使用，所以通常会一起引用，所以也要导入import numpy as npimport num
复制链接

扫一扫