Python基础 — Pandas

原文链接：https://blog.csdn.net/qq_38328378/article/details/80833091
原文作者：Is秦

---

---

Pandas -- 简介

        Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
        Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

数据结构

        Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。
        Time- Series：以时间为索引的Series。
        DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。以下的内容主要以DataFrame为主。
        Panel ：三维的数组，可以理解为DataFrame的容器。

主要功能

1. 具备对齐功能的数据结构DataFrame（一维）、Series（二维）、Panel（三维）；
2. 集成时间序列功能；
3. 提供丰富的数学运算和操作；
4. 灵活处理缺失数据；

数据帧（DataFrame）

        数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列。

        数据帧(DataFrame)的功能特点：

• 潜在的列是不同的类型
• 大小可变
• 标记轴(行和列)
• 可以对行和列执行算术运算

pandas.DataFrame

pandas中的DataFrame可以使用以下构造函数创建 ：

pandas.DataFrame( data, index, columns, dtype, copy)
   
   

构造函数的参数如下 ：

编号	参数	描述
1	data	数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame
2	index	对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值
3	columns	对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
4	dtype	每列的数据类型。
5	cope	如果默认值为False，则此命令(或任何它)用于复制数据。

创建DataFrame

Pandas数据帧(DataFrame)可以使用各种输入创建，如 ：

• 列表
• 字典
• 系列
• Numpy ndarrays
• 另一个数据帧(DataFrame)

1、创建一个空的数据帧（DataFrame）

        创建基本数据帧是空数据帧。

   
   
#创建空数据帧
import pandas as pd
df = pd.DataFrame()
print(df)
   
   

        执行结果 

   
   
Empty DataFrame
Columns: []
Index: []
   
   

2、从列表创建数据帧（DataFrame）

        可以使用单个列表或列表列表创建数据帧。

       ①使用单个列表创建数据帧

   
   
import pandas as pd
data = [ 1, 2, 3, 4, 5]
df = pd.DataFrame(data)
print(df)
   
   

        执行结果 

   
   
0
0 1
1 2
2 3
3 4
4 5
   
   

       ②使用多个列表创建数据帧

   
   
import pandas as pd
data = [[ 'Alex', 10],[ 'Bob', 12],[ 'Clarke', 13]]
df = pd.DataFrame(data,columns=[ 'Name', 'Age'])
print(df)
   
   

        执行结果 

   
   
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
   
   

3、从ndarray/Lists的字典来创建数据帧（DataFrame）

        所有的ndarrays必须具有相同的长度。如果传递了索引(index)，则索引的长度应等于数组的长度。
        如果没有传递索引，则默认情况下，索引将为range(n)，其中n为数组长度。

        ①分配给每个使用函数range(n)的默认索引。

   
   
import pandas as pd
data = { 'Name':[ 'Tom', 'Jack', 'Steve', 'Ricky'], 'Age':[ 28, 34, 29, 42]}
df = pd.DataFrame(data)
print(df)
   
   

        执行结果 

   
   
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 Ricky
   
   

        ②使用数组创建一个索引的数据帧

   
   
import pandas as pd
data = { 'Name':[ 'Tom', 'Jack', 'Steve', 'Ricky'], 'Age':[ 28, 34, 29, 42]}
df = pd.DataFrame(data, index=[ 'rank1', 'rank2', 'rank3', 'rank4'])
print(df)
   
   

        index参数为每行分配一个索引，执行结果 

         Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

从列表创建数据帧DataFrame

        字典列表可作为输入数据传递以用来创建数据帧(DataFrame)，字典键默认为列名。

1、通过传递字典列表来创建数据帧(DataFrame)

   
   
import pandas as pd
data = [{ 'a': 1, 'b': 2},{ 'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)
   
   

执行结果 

   
   
a b c
0 1 2 NaN
1 5 10 20.0
   
   

2、通过传递字典列表和行索引来创建数据帧(DataFrame)

   
   
import pandas as pd
data = [{ 'a': 1, 'b': 2},{ 'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=[ 'first', 'second'])
print(df)
   
   

执行结果 

   
   
a b c
first 1 2 NaN
second 5 10 20.0
   
   

3、使用字典，行索引和列索引列表创建数据帧(DataFrame)

   
   
import pandas as pd
data = [{ 'a': 1, 'b': 2},{ 'a': 5, 'b': 10, 'c': 20}]

#对于两个列索引，值与字典键相同
df1 = pd.DataFrame(data, index=[ 'first', 'second'], columns=[ 'a', 'b'])

#有两个列索引，一个索引有其他名称
df2 = pd.DataFrame(data, index=[ 'first', 'second'], columns=[ 'a', 'b1'])
print(df1)
print(df2)
   
   

执行结果 

   
   
#输出df1
a b
first 1 2
second 5 10

#输出df2
a b1
first 1 NaN
second 5 NaN
   
   

        注意：df2 使用字典键以外的列索引创建DataFrame; 因此，附加了NaN到位置上。 而df1是使用列索引创建的，与字典键相同，所以也附加了NaN

从系列的字典来创建DataFrame

        字典的系列可以传递以形成一个DataFrame。 所得到的索引是通过的所有系列索引的并集。

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df)
   
   

对于第一个系列，观察到没有传递标签'd'，但在结果中，对于d标签，附加了NaN。执行结果 

   
   
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
   
   

1、列选择：通过从数据帧(DataFrame)中选择一列

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df [ 'one'])
   
   

执行结果 

   
   
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float64
   
   

2、列添加：通过向现有数据框添加一个新列

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

# 通过传递新的系列，向具有列标签的现有DataFrame对象添加新的列

print ( "通过系列添加新列:")
df[ 'three']=pd.Series([ 10, 20, 30],index=[ 'a', 'b', 'c'])
print(df)

print ( "使用DataFrame中的现有列添加新列:")
df[ 'four']=df[ 'one']+df[ 'three']

print(df)
   
   

执行结果 

   
   
通过系列添加新列:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN

使用DataFrame中的现有列添加新列:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN
   
   

3、列删除：列可以删除或弹出

   
   
# 使用前面的DataFrame，我们将删除一个列
# 使用del函数
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd']),
'three' : pd.Series([ 10, 20, 30], index=[ 'a', 'b', 'c'])}

df = pd.DataFrame(d)
print ( "Dataframe is:")
print(df)

# 使用del函数
print ( "使用del函数删除第一行:")
del df[ 'one']
print(df)

# 使用pop函数
print ( "使用pop函数删除:")
df.pop( 'two')
print(df)
   
   

执行结果 

   
   
Dataframe is:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4

使用 del函数删除第一行:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4

使用pop函数删除第二行:
three
a 10.0
b 20.0
c 30.0
d NaN
   
   

行选择，添加和删除

1、标签选择

        可以通过将行标签传递给loc()函数来选择行

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df.loc[ 'b'])
   
   

执行结果 

   
   
one 2.0
two 2.0
Name: b, dtype: float64
   
   

2、按整数位置选择

        可以通过将整数位置传递给iloc()函数来选择行。

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df.iloc[ 2])
   
   

执行结果 

one   3.0
two   3.0
Name: c, dtype: float64

3、行切片

        可以使用:运算符选择多行。

   
   
import pandas as pd

d = { 'one' : pd.Series([ 1, 2, 3], index=[ 'a', 'b', 'c']),
'two' : pd.Series([ 1, 2, 3, 4], index=[ 'a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df[ 2: 4])
   
   

执行结果 

   
   
one two
c 3.0 3
d NaN 4
   
   

4、添加行

        使用append()函数将新行添加到DataFrame。

   
   
import pandas as pd

df = pd.DataFrame([[ 1, 2], [ 3, 4]], columns = [ 'a', 'b'])
df2 = pd.DataFrame([[ 5, 6], [ 7, 8]], columns = [ 'a', 'b'])

df = df.append(df2)
print(df)
   
   

执行结果 

   
   
a b
0 1 2
1 3 4
0 5 6
1 7 8
   
   

5、删除行

        使用 drop（标签）函数从DataFrame中删除或删除行。 如果标签重复，则会删除多行。

   
   
import pandas as pd

df = pd.DataFrame([[ 1, 2], [ 3, 4]], columns = [ 'a', 'b'])
df2 = pd.DataFrame([[ 5, 6], [ 7, 8]], columns = [ 'a', 'b'])

df = df.append(df2)

# 删除标签为0的行
df = df.drop( 0)

print(df)
   
   

执行结果 

   
   
a b
1 3 4
1 7 8
   
   

系列（Series）

        系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组。

        轴标签统称为索引。

Pandas系列可以使用以下构造函数创建 ：

pandas.Series( data, index, dtype, copy)
   
   

构造函数的参数如下：

编号	参数	描述
1	data	数据采取各种形式，如： ndarray，list，constants
2	index	索引值必须是唯一的和散列的，与数据的长度相同。 默认np.arange(n)  ，如果没有索引被传递。
3	dtype	dtype 用于数据类型。如果没有，将推断数据类型
4	copy	复制数据，默认为false

可以使用各种输入创建一个系列，如 :

• 数组
• 字典
• 标量值或常数

创建一个空的系列

创建一个基本系列是一个空系列。

   
   
#创建空系列
import pandas as pd
s = pd.Series()
print(s)
   
   

执行结果

Series([], dtype: float64)
   
   

从ndarray创建一个系列

如果数据是ndarray，则传递的索引必须具有相同的长度。 如果没有传递索引值，那么默认的索引将是范围(n)，其中n是数组长度，即[0,1,2,3…. range(len(array))-1] - 1]。

   
   
#从ndarray创建系列
import pandas as pd
import numpy as np
data = np.array([ 'a', 'b', 'c', 'd'])
s = pd.Series(data)
print(s)
   
   

执行结果

    
    
0 a
1 b
2 c
3 d
dtype: object
    
    

这里没有传递任何索引，因此默认情况下，它分配了从0 到len(data)-1 的索引，即：0 到3。

   
   
import pandas as pd
import numpy as np
data = np.array([ 'a', 'b', 'c', 'd'])
s = pd.Series(data,index=[ 100, 101, 102, 103])
print(s)
   
   

        在这里传递了索引值。现在可以在输出中看到自定义的索引值。

输出结果

   
   
100 a
101 b
102 c
103 d
dtype: object
   
   

从字典创建一个系列

        1、字典(dict)可以作为输入传递，如果没有指定索引，则按排序顺序取得字典键以构造索引。 如果传递了索引，索引中与标签对应的数据中的值将被拉出。

   
   
#从字典创建一个系列
import pandas as pd
import numpy as np
data = { 'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print(s)
   
   

执行结果

   
   
a 0.0
b 1.0
c 2.0
dtype: float64
   
   

        2、索引顺序保持不变，缺少的元素使用NaN(不是数字)填充。

   
   
import pandas as pd
import numpy as np
data = { 'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=[ 'b', 'c', 'd', 'a'])
print(s)
   
   

执行结果

   
   
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64
   
   

从标量创建一个系列

如果数据是标量值，则必须提供索引。将重复该值以匹配索引的长度。

   
   
#从标量创建一个系列
import pandas as pd
import numpy as np
s = pd.Series( 5, index=[ 0, 1, 2, 3])
print(s)
   
   

执行结果 

   
   
0 5
1 5
2 5
3 5
dtype: int64
   
   

从具有位置的系列中访问数据

        系列中的数据可以使用类似于访问ndarray中的数据来访问。

1、检索第一个元素

        比如已经知道数组从零开始计数，第一个元素存储在零位置等等。

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索第一个元素
print(s[ 0])
   
   

执行结果 

1
   
   

2、检索系列中的前三个元素

        如果a: 被插入到其前面，则将从该索引向前的所有项目被提取。 如果使用两个参数(使用它们之间)，两个索引之间的项目(不包括停止索引)。

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索系列中前三个元素
print(s[: 3])
   
   

执行结果 

   
   
a 1
b 2
c 3
dtype: int64
   
   

3、检索最后三个元素

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索系列中最后三个元素
print(s[ -3:])
   
   

执行结果 

c  3
d  4
e  5
dtype: int64

使用标签检索数据(索引)

        一个系列就像一个固定大小的字典，可以通过索引标签获取和设置值。

1、使用索引标签值检索单个元素。

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索单个元素
print(s[ 'a'])
   
   

执行结果 

1
   
   

2、使用索引标签值列表检索多个元素。

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索多个元素
print(s[[ 'a', 'c', 'd']])
   
   

执行结果 

   
   
a 1
c 3
d 4
dtype: int64
   
   

3、如果不包含标签，则会出现异常。

   
   
import pandas as pd
s = pd.Series([ 1, 2, 3, 4, 5],index = [ 'a', 'b', 'c', 'd', 'e'])

#检索多个元素
print(s[ 'f'])
   
   

执行结果 

   
   
…
KeyError: 'f'
   
   

Pandas -- 用法

一、生成数据表 

1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用

   
   
import numpy as np
import pandas as pd
   
   

2、导入CSV或者xlsx文件

   
   
df = pd.DataFrame(pd.read_csv( 'name.csv',header= 1))
df = pd.DataFrame(pd.read_excel( 'name.xlsx'))
   
   

3、用pandas创建数据表

   
   
df = pd.DataFrame({ "id":[ 1001, 1002, 1003, 1004, 1005, 1006],
                  "date":pd.date_range( '20180102', periods= 6),
                 "city":[ 'Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
                "age":[ 23, 44, 54, 32, 34, 32],
                "category":[ '100-A', '100-B', '110-A', '110-C', '210-A', '130-F'],
            "price":[ 1200,np.nan, 2133, 5433,np.nan, 4432]},
                columns =[ 'id', 'date', 'city', 'category', 'age', 'price'])
   
   

二、数据表信息查看 

1、维度查看

df.shape
   
   

2、数据表基本信息（维度、列名称、数据格式、所占空间等）

df.info()
   
   

3、每一列数据的格式

df.dtypes
   
   

4、某一列格式

df['B'].dtype
   
   

5、判断空值

df.isnull()
   
   

6、查看某一列的唯一值

df['B'].unique()
   
   

7、查看数据表的值

df.values
   
   

8、查看列名称

df.columns
   
   

9、查看前10行数据、后10行数据

   
   
df.head() #默认前10行数据
df.tail() #默认后10 行数据
   
   

三、数据表清洗 

1、用数字0填充空值

df.fillna(value=0)
   
   

2、使用列prince的均值对NA进行填充

df['prince'].fillna(df['prince'].mean())
   
   

3、清楚city字段的字符空格

df['city'] = df['city'].map(str.strip)
   
   

4、大小写转换

df['city']=df['city'].str.lower()
   
   

5、更改数据格式

df['price'].astype('int')
   
   

6、更改列名称

df.rename(columns={'category': 'category-size'})
   
   

7、删除后出现的重复值

df['city'].drop_duplicates()
   
   

8、删除先出现的重复值

df['city'].drop_duplicates(keep='last')
   
   

9、数据替换

df['city'].replace('sh', 'shanghai')
   
   

四、数据预处理

   
   
df1=pd.DataFrame({ "id":[ 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
                  "gender":[ 'male', 'female', 'male', 'female', 'male', 'female', 'male', 'female'],
                "pay":[ 'Y', 'N', 'Y', 'Y', 'N', 'Y', 'N', 'Y',],
                "m-point":[ 10, 12, 20, 40, 40, 40, 30, 20]})
   
   

1、数据表合并

   
   
df_inner=pd.merge(df,df1,how= 'inner') # 匹配合并，交集
df_left=pd.merge(df,df1,how= 'left') #
df_right=pd.merge(df,df1,how= 'right')
df_outer=pd.merge(df,df1,how= 'outer') #并集
   
   

2、设置索引列

df_inner.set_index('id')
   
   

3、按照特定列的值排序

df_inner.sort_values(by=['age'])
   
   

4、按照索引列排序

df_inner.sort_index()
   
   

5、如果prince列的值>3000，group列显示high，否则显示low

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')
   
   

6、对复合多个条件的数据进行分组标记

df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1
   
   

7、对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size

pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))
   
   

8、将完成分裂后的数据表和原df_inner数据表进行匹配

df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)
   
   

五、数据提取 

        主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。 

1、按索引提取单行的数值

df_inner.loc[3]
   
   

2、按索引提取区域行数值

df_inner.iloc[0:5]
   
   

3、重设索引

df_inner.reset_index()
   
   

4、设置日期为索引

df_inner=df_inner.set_index('date') 
   
   

5、提取4日之前的所有数据

df_inner[:'2018-01-04']
   
   

6、使用iloc按位置区域提取数据

df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。
   
   

7、适应iloc按位置单独提起数据

df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列
   
   

8、使用ix按索引标签和位置混合提取数据

df_inner.ix[:'2018-01-03',:4] #2018-01-03号之前，前四列数据
   
   

9、判断city列的值是否为北京

df_inner['city'].isin(['beijing'])
   
   

10、判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来

df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])] 
   
   

11、提取前三个字符，并生成数据表

pd.DataFrame(category.str[:3])
   
   

六、数据筛选 

        使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。 

1、使用“与”进行筛选

df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]

   
   

2、使用“或”进行筛选

df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age']) 

   
   

3、使用“非”条件进行筛选

   
   
df_inner.loc[(df_inner[ 'age'] > 25) | (df_inner[ 'city'] == 'beijing'), [ 'id', 'city', 'age', 'category', 'gender']].sort([ 'age'])

   
   

4、对筛选后的数据按city列进行计数

df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()

   
   

5、使用query函数进行筛选

df_inner.query('city == ["beijing", "shanghai"]')
   
   

6、对筛选后的结果按prince进行求和

df_inner.query('city == ["beijing", "shanghai"]').price.sum()
   
   

七、数据汇总 

        主要函数是groupby和pivote_table 

1、对所有的列进行计数汇总

df_inner.groupby('city').count()
   
   

2、按城市对id字段进行计数

df_inner.groupby('city')['id'].count()
   
   

3、对两个字段进行汇总计数

df_inner.groupby(['city','size'])['id'].count()
   
   

4、对city字段进行汇总，并分别计算prince的合计和均值

df_inner.groupby('city')['price'].agg([len,np.sum, np.mean]) 
   
   

八、数据统计 

        数据采样，计算标准差，协方差和相关系数 

1、简单的数据采样

df_inner.sample(n=3) 
   
   

2、手动设置采样权重

   
   
weights = [ 0, 0, 0, 0, 0.5, 0.5]
df_inner.sample(n= 2, weights=weights)
   
   

3、采样后不放回

df_inner.sample(n=6, replace=False) 
   
   

4、采样后放回

df_inner.sample(n=6, replace=True)

   
   

5、数据表描述性统计

df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置

   
   

6、计算列的标准差

df_inner['price'].std()
   
   

7、计算两个字段间的协方差

df_inner['price'].cov(df_inner['m-point']) 

   
   

8、数据表中所有字段间的协方差

df_inner.cov()
   
   

9、两个字段的相关性分析

df_inner['price'].corr(df_inner['m-point']) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关

   
   

10、数据表的相关性分析

df_inner.corr()

   
   

九、数据输出 

        分析后的数据可以输出为xlsx格式和csv格式 

1、写入Excel

df_inner.to_excel('excel_to_python.xlsx', sheet_name='bluewhale_cc') 

   
   

2、写入到CSV

df_inner.to_csv('excel_to_python.csv')