Pandas

Posted foremostxl

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Pandas相关的知识,希望对你有一定的参考价值。

Pandas基本介绍

Numpy 和 Pandas 有什么不同 

如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的,没有数值标签,而 Pandas 就是字典形式。

Pandas是基于Numpy构建的,让Numpy为中心的应用变得更加简单。 要使用pandas,首先需要了解他主要两个数据结构:Series和DataFrame。

series(系列,连续)  /‘s??ri?z; -r?z/  /‘s?riz/ 

Series是一种类似于一维数组的对象,它由一组数组(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成

仅由一组数据即可产生最简单的Series:

import pandas as pd
obj = pd.Series([4,7,-5,3])
# 对应索引和值
print(obj)
0    4
1    7
2   -5
3    3
dtype: int64

# Series的字符串表现形式为:索引在左边,值在右边。
# 由于我们没有为数据指定索引。于是会自动创建一个0到N-1(N为长度)的整数型索引。

# 可以通过Series的values和index属性获取其数组表示形式和索引对象
print(obj.values)
print(obj.index)
[ 4  7 -5  3]
RangeIndex(start=0, stop=4, step=1)

# 可以自己创建索引
obj2 = pd.Series([4,7,-5,3],index=[d,b,a,c])
print(obj2)

d    4
b    7
a   -5
c    3
dtype: int64

# 根据索引取值
print(obj2[a])
print(obj2[[c,a,d]])
-5
c    3
a   -5
d    4
dtype: int64


import pandas as pd
import numpy as np
# nan=none
s = pd.Series([1,3,6,np.nan,44,1])
print(s)
0     1.0
1     3.0
2     6.0
3     NaN
4    44.0
5     1.0
dtype: float64
# DataFrame是一个表格型的数据结构,它包含有一组有序的列,每列可以是不同的值类型(数值,字符串,布尔值等)

# DataFrame既有行索引也有列索引, 它可以被看做由Series组成的大字典。
dates = pd.date_range(20190207,periods=6)
# periods=6 生成6个数据

# np的random函数
# numpy中有一些常用的用来产生随机数的函数,randn()和rand()就属于这其中。 
# numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值。 
# numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。 

df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=[a,b,c,d])
# 行index  列columns
print(df)

                  a         b         c         d
2019-02-07 -0.292233  0.422153  2.262461  0.179207
2019-02-08  1.982641  1.299313 -1.000942 -0.041675
2019-02-09  1.162939 -0.296554  1.437283 -0.104282
2019-02-10 -2.609355 -0.188624  1.161949 -0.510447
2019-02-11 -0.277941 -0.542832 -1.356549  1.004631
2019-02-12 -0.258218  0.635150  1.513197 -1.672800

print(df[b])
2019-02-07    0.422153
2019-02-08    1.299313
2019-02-09   -0.296554
2019-02-10   -0.188624
2019-02-11   -0.542832
2019-02-12    0.635150
Freq: D, Name: b, dtype: float64

#我们在创建一组没有给定行标签和列标签的数据 df1:
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
# 默认index从0开始
print(df1)

   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

# 字典的方式
df2 = pd.DataFrame({A : 1.,
                    B : pd.Timestamp(20130102),
                    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(df2)
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo

# 这种方法能对每一列的数据进行特殊对待. 如果想要查看数据中的类型, 我们可以用 dtype 这个属性:

print(df2.dtypes)
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

print(df2.index)

Int64Index([0, 1, 2, 3], dtype=int64)
# 同样, 每种数据的名称也能看到:
print(df2.columns)
Index([A, B, C, D, E, F], dtype=object)

# 如果只想看所有df2的值:
print(df2.values)
[[1.0 Timestamp(2013-01-02 00:00:00) 1.0 3 test foo]
 [1.0 Timestamp(2013-01-02 00:00:00) 1.0 3 train foo]
 [1.0 Timestamp(2013-01-02 00:00:00) 1.0 3 test foo]
 [1.0 Timestamp(2013-01-02 00:00:00) 1.0 3 train foo]]
# 想知道数据的总结, 可以用 describe():
print(df2.describe())

         A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0
# 如果想翻转数据, transpose:
print(df2.T)

                    0                    1                    2  A                    1                    1                    1   
B  2013-01-02 00:00:00  2013-01-02 00:00:00  2013-01-02 00:00:00   
C                    1                    1                    1   
D                    3                    3                    3   
E                 test                train                 test   
F                  foo                  foo                  foo   

                     3  
A                    1  
B  2013-01-02 00:00:00  
C                    1  
D                    3  
E                train  
F                  foo  

# 如果想对数据的 index 进行排序并输出:
# ascending=False 倒的序列进行排序
print(df2.sort_index(axis=1, ascending=False))

     F      E  D    C          B    A
0  foo   test  3  1.0 2013-01-02  1.0
1  foo  train  3  1.0 2013-01-02  1.0
2  foo   test  3  1.0 2013-01-02  1.0
3  foo  train  3  1.0 2013-01-02  1.0

# 如果是对数据 值 排序输出:
print(df2.sort_values(by=E))
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
2  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
3  1.0 2013-01-02  1.0  3  train  foo

Pandas 选择数据

简单的筛选
根据标签 loc
根据序列 iloc
根据混合的这两种 ix
通过判断的筛选
dates = pd.date_range(20130101, periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=[A,B,C,D])
print(df)

             A   B   C   D
2013-01-01   0   1   2   3
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23

# 简单的筛选 
# 如果我们想选取DataFrame中的数据,下面描述了两种途径, 他们都能达到同一个目的:

print(df[A])
print(-------------------)
print(df.A)

2013-01-01     0
2013-01-02     4
2013-01-03     8
2013-01-04    12
2013-01-05    16
2013-01-06    20
Freq: D, Name: A, dtype: int32
-------------------
2013-01-01     0
2013-01-02     4
2013-01-03     8
2013-01-04    12
2013-01-05    16
2013-01-06    20
Freq: D, Name: A, dtype: int32
# 让选择跨越多行或多列:
# 选择0:3行的数据
print(df[0:3])
print(-----------------------------)
print(df[20130102:20130104])

            A  B   C   D
2013-01-01  0  1   2   3
2013-01-02  4  5   6   7
2013-01-03  8  9  10  11
-----------------------------
             A   B   C   D
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
# 根据标签 loc
# 同样我们可以使用标签来选择数据 loc, 本例子主要通过标签名字选择某一行数据, 
# 或者通过选择某行或者所有行(:代表所有行)然后选其中某一列或几列数据。

print(df.loc[20130102])

A    4
B    5
C    6
D    7
Name: 2013-01-02 00:00:00, dtype: int32
print(df.loc[:,[A,B]]) 

             A   B
2013-01-01   0   1
2013-01-02   4   5
2013-01-03   8   9
2013-01-04  12  13
2013-01-05  16  17
2013-01-06  20  21

print(df.loc[20130102,[A,B]])
A    4
B    5
Name: 2013-01-02 00:00:00, dtype: int32

# 根据  序列 iloc 
# 另外我们可以采用位置进行选择 iloc, 在这里我们可以通过位置选择在不同情况下所需要的数据例如选某一个,
# 连续选或者跨行选等操作。

print(df.iloc[3,1])
13
print(df.iloc[3:5,1:3])
# 3\4两列,1,2两行
          B   C
2013-01-04  13  14
2013-01-05  17  18

print(df.iloc[[1,3,5],1:3]) # 行和列
          B   C
2013-01-02   5   6
2013-01-04  13  14
2013-01-06  21  22
# 根据混合的这两种 ix 
# 当然我们可以采用混合选择 ix, 其中选择’A’和’C’的两列,并选择前三行的数据。

print(df.ix[:3,[A,C]])
         A   C
2013-01-01  0   2
2013-01-02  4   6
2013-01-03  8  10
# 通过判断的筛选
print(df[df.A>8])

             A   B   C   D
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23

Pandas 设置值

创建数据
根据位置设置 loc 和 iloc
根据条件设置
按行或列设置
添加数据

 

  1.loc意义:通过行标签索引行数据
       例: loc[n]表示索引的是第n行(index 是整数)

              loc[‘d’]表示索引的是第’d’行(index 是字符)

   2. .iloc   :通过行号获取行数据,不能是字符

3.  ix——结合前两种的混合索引

三者区别: 

ix / loc 可以通过行号和行标签进行索引,比如 df.loc[a] , df.loc[1], df.ix[a] , df.ix[1]

而iloc只能通过行号索引 , df.iloc[0] 是对的, 而df.iloc[a] 是错误的

 

dates = pd.date_range(20130101, periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=[A,B,C,D])
print(df)
             A   B   C   D
2013-01-01   0   1   2   3
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23

# 根据位置设置 loc 和 iloc 
df.iloc[2,2] = 1111
print(df)
print(---------------------------------)
df.loc[20130101,B] = 2222
print(df)
             A   B     C   D
2013-01-01   0   1     2   3
2013-01-02   4   5     6   7
2013-01-03   8   9  1111  11
2013-01-04  12  13    14  15
2013-01-05  16  17    18  19
2013-01-06  20  21    22  23
---------------------------------
             A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     9  1111  11
2013-01-04  12    13    14  15
2013-01-05  16    17    18  19
2013-01-06  20    21    22  23
# 根据条件设置

# 如果现在的判断条件是这样, 我们想要更改B中的数, 而更改的位置是取决于 A 的. 
# 对于A大于4的位置. 更改B在相应位置上的数为0.

df.B[df.A>4] = 0
print(df)
             A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     0  1111  11
2013-01-04  12     0    14  15
2013-01-05  16     0    18  19
2013-01-06  20     0    22  23

# 按行或列设置

# 如果对整列做批处理, 加上一列 ‘F’, 并将 F 列全改为 NaN, 如下:

df[F] = np.nan
print(df)
             A     B     C   D   F
2013-01-01   0  2222     2   3 NaN
2013-01-02   4     5     6   7 NaN
2013-01-03   8     0  1111  11 NaN
2013-01-04  12     0    14  15 NaN
2013-01-05  16     0    18  19 NaN
2013-01-06  20     0    22  23 NaN

# 添加数据 
# 用上面的方法也可以加上 Series 序列(但是长度必须对齐)。

df[E] = pd.Series([1,2,3,4,5,6], index=pd.date_range(20130101,periods=6)) 
print(df)
             A     B     C   D   F  E
2013-01-01   0  2222     2   3 NaN  1
2013-01-02   4     5     6   7 NaN  2
2013-01-03   8     0  1111  11 NaN  3
2013-01-04  12     0    14  15 NaN  4
2013-01-05  16     0    18  19 NaN  5
2013-01-06  20     0    22  23 NaN  6

Pandas 处理丢失数据

创建含 NaN 的矩阵
pd.dropna()
pd.fillna()
pd.isnull()

 

 

Pandas 处理丢失数据
#有时候我们导入或处理数据, 会产生一些空的或者是 NaN 数据,如何删除或者是填补这些 NaN 数据就是我们今天所要提到的内容.

#建立了一个6X4的矩阵数据并且把两个位置置为空.

dates = pd.date_range(20130101, periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=[A,B,C,D])
print(df)
print(---------------------------)
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan
print(df)

             A   B   C   D
2013-01-01   0   1   2   3
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23
---------------------------
             A     B     C   D
2013-01-01   0   NaN   2.0   3
2013-01-02   4   5.0   NaN   7
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23

# pd.dropna()

# 如果想直接去掉有 NaN 的行或列, 可以使用 dropna

a = df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作
    how=any   # ‘any‘: 只要存在 NaN 就 drop 掉; ‘all‘: 必须全部是 NaN 才 drop 
    ) 
print(a)
             A     B     C   D
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
# pd.fillna() 
# 如果是将 NaN 的值用其他值代替, 比如代替成 0:

print(df.fillna(value=0))
             A     B     C   D
2013-01-01   0   0.0   2.0   3
2013-01-02   4   5.0   0.0   7
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
# pd.isnull()
# 判断是否有缺失数据 NaN, 为 True 表示缺失数据:
print(df.isnull())

                A      B      C      D
2013-01-01  False   True  False  False
2013-01-02  False  False   True  False
2013-01-03  False  False  False  False
2013-01-04  False  False  False  False
2013-01-05  False  False  False  False
2013-01-06  False  False  False  False
# 检测在数据中是否存在 NaN, 如果存在就返回 True:‘‘
np.any(df.isnull()) == True  
True

Pandas 导入导出

读取和保存的格式

 技术图片技术图片

技术图片

pandas可以读取与存取的资料格式有很多种,像csv、excel、json、html与pickle等…, 详细请看官方说明文件

读取csv 

import pandas as pd #加载模块

#读取csv
data = pd.read_csv(student.csv)

#打印出data
print(data)

    Student ID  name   age  gender
0         1100  Kelly   22  Female
1         1101    Clo   21  Female
2         1102  Tilly   22  Female
3         1103   Tony   24    Male
4         1104  David   20    Male
5         1105  Catty   22  Female
6         1106      M    3  Female
7         1107      N   43    Male
8         1108      A   13    Male
9         1109      S   12    Male
10        1110  David   33    Male
11        1111     Dw    3  Female
12        1112      Q   23    Male
13        1113      W   21  Female

将资料存取成pickle 
data.to_pickle(student.pickle)

Pandas 合并 concat

要点
axis (合并方向)
ignore_index (重置 index)
join (合并方式)
join_axes (依照 axes 合并)
append (添加数据)
pandas处理多组数据的时候往往会要用到数据的合并处理,使用 concat是一种基本的合并方式.
而且concat中有很多参数可以调整,合并成你想要的数据形式.

 

 

 

 

 

 

 

 

 

 

 

 

 

以上是关于Pandas的主要内容,如果未能解决你的问题,请参考以下文章

text [检查特定的数据片段]取自论文但有意思应用。 #python #pandas

Python:用于元组的 Pandas DataFrame

pandas 求两个时间差, 转化秒,判断时间差是否大于阈值

将pandas列中的列表列表转换为字符串

微信小程序代码片段

VSCode自定义代码片段——CSS选择器