Pandas学习-基础

Pandas学习-基础

1、Pandas介绍

​ Pandas支持大部分Numpy语言风格，特别是常用到的数组函数与广播机制的各种数据处理。但是Numpy更适合处理同质型的数据，Pandas在Numpy的基础上进行深入设计，常用于处理表格或者异质型的这一类数据，具有高效的清洗、处理数据能力。我们经常在数据分析时，用来读取数据集做数据清洗处理，实现快速。

​ Pandas是基于Numpy的一种工具，它提供了高性能的运算，主要是为了解决数据分析任务而创建的，是贯穿整个Python数据分析非常核心的工具。

​ 涉及到的内容：1、Pandas基础，2、数据清洗与准备，3数据聚合与分组，4、时间序列

2、Pandas安装

​ win+R调用dos命令框输入cmd运行，直接pip install pandas。如果下载太慢采用换源安装（这里是清华的源）：pip install pandas -i http://pypi.mirrors.ustc.edu.cn/simple/。倘若安装失败换其他源进行安装（阿里云、豆瓣等）。

3、Pandas基础数据结构

3.1、pandas数据结构介绍

• pandas的创建方法有两种，一种是Series,另外一种是DataFrame创建。

• Series介绍

  Series是一种一维的数组型对象，包含了一个值序列（values）,并且包含了数据标签，称为索引（index）

• Series创建

  pd.Series(data=None,index=None,dtype=None,name=Name,copy=Falsee)

  • data：创建数组的数据，可写为arayy-like,dict,or scalar value
  • index：指定索引
  • dtype：数组数据 类型
  • name：数组名称
  • copy：是否拷贝

  data可以是iterable,dict,or scalar value

• 列表创建Series

• 本文是通过jupyter notebook进行书写代码，基本上少写了print（）语句，直接输出。

3.2、Series创建方法

import numpy as np
import pandas as pd
a = np.array([1,2,3])    # 通过之前numpy进行创建
a   # 打印输出:array([1, 2, 3])
s = pd.Series([1,2,3,4,5])
s

# 输出：
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5
# dtype: int64

type(s)   # 输出s的类型：pandas.core.series.Series

s.index		# RangeIndex(start=0, stop=5, step=1)
# 代表[0:5:1]  从0开始到4，步长为1

s.values	# array([1, 2, 3, 4, 5], dtype=int64)

s.dtype		# dtype('int64')

---

• 元组创建Series对象

s1 = pd.Series((1,2,3,4,5))
s1 

# 输出：
# 0    1
# 1    2
# 2    3
# 3    4
# 4    5
# dtype: int64

• 数组创建Series对象

a = np.array([1,2,3])
s2 = pd.Series(a)
s2

# 输出
# 0    1
# 1    2
# 2    3
# dtype: int32

# 修改标签(index) 名
s2 = pd.Series(a,index=['a','b','c'])
s2

# 输出
# a    1
# b    2
# c    3
# dtype: int32

• 通过字典创建对象

s3 = pd.Series({
    
    'name':'松花'，'age':'18','sex':'男'})
s3

# 输出：
# name    松花
# age     18
# sex      男
# dtype: object

s3 = pd.Series({
    
    'name':'松花'，'age':'18','sex':'男'},inidex=['a','b','c'])
s3     # 显示缺失值，并没有修改其标签，指定以后不能轻易修改，除非是上面那种默认的标签(0,1,2,3)

# 输出：
# a    NaN
# b    NaN
# c    NaN
# dtype: object

# 添加标签
s3 = pd.Series({
    
    'name':'松花'，'age':'18','sex':'男'},index=['name','age','sex','class'])
s3    # 多加一个标签，可以加，但是，是一个缺失值

# 输出：
# name      松花
# age       18
# sex        男
# class    NaN
# dtype: object

3.3、Series的基本使用

1、通常使用列表或者字典形式进行创建Series对象，可迭代类型均可以创建；

import pandas as pd
pd.Series([1,2,3,4,5,6])    # data为iterable

2、索引默认为range(0,n)可以通过index指定索引

pd.Series([1,2,3,4,5],index=list('abcde'))

# 输出：
# a    1
# b    2
# c    3
# d    4
# e    5
# dtype: int64

3、数据类型根据data自动调整，但是也可以通过dtype指定

pd.Series(np.random.randint(1,10,size=5),dtype='float')

# 输出：
# 0    6.0
# 1    7.0
# 2    5.0
# 3    7.0
# 4    3.0
# dtype: float64

4、使用name参数设置数组名称

pd.Series(np.random.randint(1,10,size=3),index=list('abc'),name='data_name')

# 输出：
# a    6
# b    1
# c    7
# Name: data_name, dtype: int32

除此之外还可以使用Numpy的数组函数。

• s.dtype—>查看数据类型
• s.astype()—>修改数据类型
• s.head(n)—>预览前面n条数据
• s.tail(n)—>预览后几条数据

但是如果需要显示所有数据，则需要以下代码。但并不建议使用

#显示所有列
pd.set_option('display.max_columns', None)

#显示所有行
pd.set_option('display.max_rows', None)

#设置value的显示长度为100，默认为50
pd.set_option('max_colwidth',100)

---

3.4、Seriesd的索引与值

• s.index—>查看索引
• s.values—>查看值序列
• s.reset_index(drop=False)—>重置索引
  • drop—>是否删除原索引默认为否

3.4.1注意：

• 索引对象是不可变的，所以不能单个修改索引

---

3.5、Series索引与切片

• s[‘标签’]：通过标签

• s[‘索引’]：通过索引

• s.loc(标签)：通过标签

• s.iloc(索引)：通过索引

  ---

3.5.1、索引切片取值

• 没有共同索引时，则全部为NaN

s3 = pd.Series(d,index=['name','age','sex','class'])   # 多加一个标签，可以加，但是，是一个缺失值
s3

# 输出：
# name      松花
# age       18
# sex        男
# class    NaN
# dtype: object

• index取值

s3.index	# 取出s3中的标签

# 输出：
# Index(['name', 'age', 'sex', 'class'], dtype='object')

• 索引取值

# 取值，位置索引，下标取值
s3[0]

# 输出：'松花'

• 标签取值

# 标签名索引，类似于字典的键值取值
s3['name']

# 输出：'松花'

• 多个数据选取

# 选择多个数据
s3[[0,2]]     # 取到小标为0和2的值

# 输出：
# name    松花
# sex      男
# dtype: object

s3[['name','sex']]

# 输出：
# name    松花
# sex      男
# dtype: object

• 下标切片

# 下标切片，左闭右开
s3[0:2]

# 输出：
# name    松花
# sex      男
# dtype: object

• 标签切片

# 标签切片，包含末端数据
s3['name':'sex']

# 输出：
# name    松花
# age     18
# sex      男
# dtype: object

s3['name':'class':2]    # 步长为2

# 输出：
# name    松花
# sex      男
# dtype: object

• 布尔索引

上述s2输出为：
a    1
b    2
c    3
dtype: int32

# 布尔索引
s2>2

# 输出：
# a    False
# b    False
# c     True
# dtype: bool

这里将s2中大于2的元素进行判断，大于返回True,将该值s2[s2>2]则输出大于2的数

s2[s2>2]

# 输出：
# c    3
# dtype: int32

属性

# 属性
s2.name = '人数'   # 对象名称
s2.index.name = '班级'     # 索引对象名称
s2

# 输出：
# 班级
# a    1
# b    2
# c    3
# Name: 人数, dtype: int32

---

3.6、Seires运算

s2的结果：
班级
a    1
b    2
c    3
Name: 人数, dtype: int32

---

1、head()

# 前几条数据   默认为5   要显示几个数值就放几个数值
s2.head()

# 输出：
# 班级
# a    1
# b    2
# c    3
# Name: 人数, dtype: int32

2、tail()

# 显示后几条数据
s2.tail(2)

# 输出：
# 班级
# b    2
# c    3
# Name: 人数, dtype: int32

---

3、检测缺失值

s3

name      松花
age       18
sex        男
class    NaN
dtype: object

# 检测缺失值
s3.isnull()        # NaN数值返回True

# 输出：
# name     False
# age      False
# sex      False
# class     True
# dtype: bool

~s3.notnull()    # 也用于检测缺失值

# 输出：
# name     False
# age      False
# sex      False
# class     True
# dtype: bool

---

---

4、DataFrame()的创建使用

4.1、DataFrame介绍

DataFrame表示的是矩阵的数据表，它包含已经排序的列集合，每一列可以是不同的值类型（数值、字符串、布尔值）。在DtatFrame中，数据被存储为一个以上的二维块。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-auUAYyCZ-1658308305490)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170137684.png)]

4.2、DataFrame创建

pd.DataFrame(data=None,index=None,columns=None,dtype=None,copy=Flae)

• data：创建数组的数据，可以为ndarray,dict
• index： 指定索引
• dtype：数组数据类型
• copy：是否拷贝

4.2.1、通过字典创建DataFrame

# 字典创建
data = {
    
    
    'A':[1,2,3],
    'B':(4,5,6),
    'C':np.arange(7,10)
}
df = pd.DataFrame(data)
df

执行后的结果为：

	A	B	C
0	1	4	7
1	2	5	8
2	3	6	9

查看数据类型:

type(df)	# pandas.core.frame.DataFrame

行索引：

df.index 		# 行索引，每一行的名称

# 打印输出：RangeIndex(start=0, stop=3, step=1)

列索引：

df.columns		# 每一行的名称

# 打印输出：Index(['A', 'B', 'C'], dtype='object')

拿到值：

df.values		# 对所有数值进行取值

# 打印输出：
array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]], dtype=int64)

对于上述中的df而言可以对行和列标签进行命名：

df = DataFrame(data,index=list('abc'),columns=list('ABC'))		# 这里可以写index=['a','b','c']形式
df		# 结果显示行标签由默认的0,1,2变为a,b,c

执行后的结果：

	B	A	C
a	4	1	7
b	5	2	8
c	6	3	9

---

注意：DataFrame()创建数组时，第一位置是数据，第二位置是每一行的标签，第三位置是每一列的标签

1、创建DataFrame数组有NaN时会使得该组数值为float类型

data = {
    
    
	'a':pd.Series(np.arange(3)),
	'b':pd.Series(np.arange(3,5))     # 取不到5
}
df2 = pd.DataFrame(data)		# 由于a能取到0,1,2；b只能取到3,4，因此第3行2列默认为NaN
df2

执行结果：

	a	b
0	0	3.0
1	1	4.0
2	2	NaN

2、字典key位置是列标签，value位置是行标签

data = {
    
    
	'a':{
    
    'apple':3.6,'banana':5.6},
	'b':{
    
    'apple':3,'banana':5},
	'c':{
    
    'apple':3.2}
}
df3 = pd.DataFrame(data)
df3

执行结果：

	a	b	c
apple	3.6	3	3.2
banana	5.6	5	NaN

4.2.2、通过数组创建DataFrame

• 1、首先通过numpy创建数组拿到数组元素

  arr = np.arange(12).reshape(3,4)
  arr		# 创建0-11的数字，并且划分为3行4列
  
  
  # 打印输出：
  array([[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]])
  

• 2、将arr装换为DataFrame

  df4 = pd.DataFrame(arr)
  df4
  

  执行结果为：

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

• 3、对上述创建的df4进行处理行标签和列标签：

  df5 = pd.DataFrame(arr,index=list('abc'),columns=list('ABCD'))
  df5				# 实现行标签为abc,列标签为ABCD
  

  执行结果为：

  	A	B	C	D
  a	0	1	2	3
  b	4	5	6	7
  c	8	9	10	11

4.2.3、通过列表嵌套字典/数组创建DataFrame

• 列表嵌套字典

  data = [{
        
        'apple':3.6,'banana':5.6},{
        
        'apple':5,'banana':3},{
        
        'apple':3.2}]
  df6 = pd.DataFrame(data)
  df6
  

  执行结果为：

  	apple	banana
  0	3.6	5.6
  1	5.0	3.0
  2	3.2	NaN

• 列表嵌套数组创建DataFrame

  data = [pd.Series(np.arange(3)),pd.Series(np.arange(3,6))]			# 构造行为0-3和3-5数字，列为2的数组
  df7 = pd.DataFrame(data)		# 将数组转换为DataFrame类型
  df7
  

  执行结果：

  	0	1	2
  0	0	1	2
  1	3	4	5

4.3、重置索引

除了创建时可以指定，我们创建后还可以通过**df.reindex()**进行重置索引。

• df.reindex(index=None,columns=None,axis=None,fill_value=nan)

1、重复索引值类型一

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MO7AJYyy-1658308305491)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170311230.png)]

2、重复索引值类型二

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3vG9rmsa-1658308305492)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\2022-07-07_101041.png)]

3、重命名索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-63nbbmEN-1658308305492)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170411644.png)]

4.4、DataFrame基础操作

• df.shape # 查看数组形状，返回值为元组
• df.dtype # 查看列数据类型
• df.ndim # 数据维度，返回为整数
• df.index # 行索引
• df.columns # 列索引
• df.values # 值
• d.head(n) # 显示头部几行，默认前5行
• d.tail(n) # 显示末尾几行，默认后5行
• d.info() # 相关信息概述

data = [
    {
    
    "name":"amy","age":18,"tel":10086},
    {
    
    "name":"bob","age":18},
    {
    
    "name":"james","tel":10086},
    {
    
    "name":"zs","tel":10086},
    {
    
    "name":"james","tel":10086},
    {
    
    "name":"ls","tel":10086},
]

d2 = pd.DataFrame(data)
d2.head()  
d2.tail()  
d2.info()  


# 输出：
'''
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   name    6 non-null      object 
 1   age     2 non-null      float64
 2   tel     5 non-null      float64
dtypes: float64(2), object(1)
memory usage: 272.0+ bytes
'''

---

4.5、DataFrame查数据（索引与切片）

直接使用索引与标签

类型	描述
df[:索引]或者df[:“标签”]	表达对行操作
df[“列标签”]或者df[[“列标签”,“列标签”]]	表示对列进行操作

创建如下表格数组：

A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

1、行查找的索引方法

方法1：

df[:'a']

执行结果：拿到第一行元素

	A	B	C
a	0	1	2

方法2：

注意：

当使用 df[:0]时我们会发现，它只是拿到了列的标签：

	A	B	C

当使用 df[:1]时，可以拿到第一行元素：

	A	B	C
a	0	1	2

---

2、列查找的索引方法

查找列数据，直接利用df[‘列标签’]

# 查找A列
df['A']


# 执行结果：
a    0
b    3
c    6
Name: A, dtype: int32

查找A列第一个元素：df['A']['a']

df['A']['a']
df


# 执行结果：
0

df[[“列标签”,“列标签”]]—>选取两行元素及更多组列数据时要用两个方括号df[['A','B']],执行结果如下所示：

	A	B
a	0	1
b	3	4
c	6	7

在实际操作当中，我们更加喜欢使用 df['列标签']拿到列所在的值，但是在拿行标签时很少用 df[:'行标签']或者df[:索引]，一般使用 df.loc[]和 df.iloc[] 拿取数据。

---

3、连续范围选取

• 1、创建数组

	A	G	B	C	d
a	0	1	1	2	999
b	3	2	4	5	999
c	6	3	7	8	999
d	1	2	3	4	5

• 2、获取a到c行元素，以及c到d列元素

# 获取a-c行元素和C-D列元素
df.loc['a':'c','C':'d']

执行结果：

	C	d
a	2	999
b	5	999
c	8	999

3、下标取值，切片操作

# 连续取值
df.iloc[0:3,3:5]

执行结果：

	C	d
a	2	999
b	5	999
c	8	999

4、具体行、列取值

# 取值1到3行数据，在取值第2、4列
df.iloc[0:3,[1,3]]

执行结果：

	G	C
a	1	2
b	2	5
c	3	8

---

4.6、使用loc以及iloc查询数据

• df.loc[] # 通过轴标签选择数据
• df.iloc[] # 通过整数索引选择数据

具体使用如下

类型	描述
df.loc[val]	根据标签索引选择DataFrame的单行或者多行
df.loc[:,val]	根据标签索引选择DataFrame的单列或者多行
df.loc[val1,val2]	同时选择行和列中的一部分
df.iloc[where]	根据位置索引选择DataFrame的单行或者多行
df.iloc[:,where]	根据位置索引选择DataFrame的单列或者多列
df.iloc[where_i,where_j]	根据位置索引选择行和列

1、loc()具体使用方法

创建数组列表如下：

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

# 高级索引
df.loc['a']        # 行索引

执行结果：

A    0
B    1
C    2
Name: a, dtype: int32

补充：df.T['a']也可以得到同样的行数据。

获取多行：df.loc[['a','b']]需要两个方括号。

效果如下：

	A	B	C
a	0	1	2
b	3	4	5

4.7、DataFrame修改数据

修改数据主要遵循以下两点

①：查询数据

②：再赋值

✔注意： Pandas中可以直接赋值np.nan，并且赋值当前列数据会自动转化为浮点类型。而不是整个数组都转，这主要是因为pandas数据可以是异质性。

创建如下数组：

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

1、修改列元素

✔**修改A列元素：**一旦修改后就会破坏原始数据

df['A'] = 9			# 修改A列元素
df

执行结果：

	A	B	C
a	9	1	2
b	9	4	5
c	9	7	8

修改A列第一个元素：

df['A']['a'] = 10     # 选择A列元素，再选择a行元素
df

执行结果：

	A	B	C
a	10	1	2
b	9	4	5
c	9	7	8

2、修改行元素

✔给第一行元素重新赋值

# 给第一行元素重新赋值
df.loc['a'] = [0,1,2]
df

执行结果：

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

4.8、DataFrame新增数据

4.8.1、新增列

df[“新的列标签”] = 值

**注意：**添加列，则新添加的值的长度必须与其他列的长度保持一致，否则会报错。

构造数组如下：

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

# 新增加一列
df['D'] = [9,99,999]
df

执行结果：

	A	B	C	D
a	0	1	2	9
b	3	4	5	99
c	6	7	8	999

4.8.2、插入列

如果需要在数据中插入列，则使用 df.insert(loc,column,value)

• loc 为插入列的位置
• column 为插入列的标签
• value 为插入列的值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-djGaR6S3-1658308305493)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170521231.png)]

4.8.3、添加行

df.loc[“新的行标签”,:] = 值

如果增加的这一行元素不是4个，那么就会报错。

1、df.loc[]添加

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6B5UqwXB-1658308305494)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170548371.png)]

2、df.append(df2)添加

除此之外，我们还可以通过 df.append(df2) 方法添加行，但是类似于数组与数组的堆叠拼接。所以df2的列索引必须同df一致。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lIYHRKDs-1658308305494)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170617641.png)]

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NUEkVOXI-1658308305494)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170644962.png)]

4.9、DataFrame删除数据

4.9.0、删除操作

1、Series对象删除

对于常规的Series对象而言，如：

a     0
b     1
c     2
d     3
f     9
g    10
dtype: int64

删除f行元素：

del s['f']
s

2、droop()删除DataFrame对象

构造如下df2数组：

	A	G	B	C	d
a	0	1	1	2	999
b	3	2	4	5	999
c	6	3	7	8	999
d	1	2	3	4	5
a	0	1	1	2	999

• 指定删除列

  df3 = df2.drop(['C','d'],axis=1)		# 指定删除C,d两列
  df3
  

  	A	G	B
  a	0	1	1
  b	3	2	4
  c	6	3	7
  d	1	2	3
  a	0	1	1

• 指定删除行

  df4 = df2.drop(['d','a'],axis=0)      # 删除d,a行
  df4
  

  	A	G	B	C	d
  b	3	2	4	5	999
  c	6	3	7	8	999

4.9.1、DataFrame算术

实际上，我们通过 + - * / // **等以上符号可以直接对DataFrame与DataFrame之间或者DataFrame以及Series之间进行运算。但是秉承的原则就是对应索引运算，存在索引不同时，返回结果为索引对的并集。

经过我们实际操作不难发现，当存在索引不同时，返回的值会自动填充NaN。

4.9.2、使用填充值的算术方法

方法	描述
add,radd	加法（+）
sub,rsub	减法（-）
div,rdiv	除法（/）
floordiv,rfloordiv	整除（//）
mul,rmul	乘法（*）
pow.rpow	幂次方（**）

注意：

• Series使用算术方法，不支持指定填充值

---

4.9.3、描述性统计的概括和计算

方法	描述
count	非NA值的个数
min,max	最小值，最大值
idxmin,idxmax	最小值，最大值的标签索引
sum	求和
mead	平均值
median	中位数
var	方差
std	标准差
cumsum	累计值
cummin,cummax	累计值的最小值或者最大值
cumprod	值的累计积
diff	计算第一个算术差值（时间序列）
pct_change	百分比
corr	按索引对其的值的相关性
cov	协方差

1、构造DataFrame

df = DataFrame([[1.4,np.nan],[7.1,-4.5],
			   [np.nan,np.nan],[0.75,-1.3]],
               index=('abcd'),
               columns = ('one','two'))
df

执行结果：

	one	two
a	1.40	NaN
b	7.10	-4.5
c	NaN	NaN
d	0.75	-1.3

---

2、求和

df.sum()		# 对所有数据进行求和

# 执行结果：
one    9.25
two   -5.80
dtype: float64
# 由以上执行结果可知对所有列数据进行求和运算

---

3、对每一行元素进行求和运算

df.sum(axis=1)			# 每一行的元素进行求和


# 执行结果：
a    1.40
b    2.60
c    0.00
d   -0.55
dtype: float64

# df.sum(axis=0)			# 每一列的元素进行求和

---

4、求每一行的最大值

df.max(axis=1)			# 每一行的最大值


# 执行结果为：
a    1.40
b    7.10
c     NaN
d    0.75
dtype: float64

---

5、向下求和

df.cumsum()				# 上面的数值一次向下累加求和

执行结果：

	one	two
a	1.40	NaN
b	8.50	-4.5
c	NaN	NaN
d	9.25	-5.8

---

6、nan替换为0

df1 = df.fillna(0)
df1

执行结果：

	one	two
a	1.40	0.0
b	7.10	-4.5
c	0.00	0.0
d	0.75	-1.3

---

7、one重新赋值，并且删除第二列

df1.one = [0,1,2,3]
df2 = df1.drop(['two',axis=1])		# 删除第二列
df2

执行结果：

	one
a	0
b	1
c	2
d	3

通过运算我们发现当涉及到行/列相加运算时axis=1代表行，axis=0代表列

涉及拼接和删除作为轴时axis=1代表列处理,axis=0代表行处理，这样方便记忆了解。

8、diff(算数差值)

df2.diff()						# 算数差值
# 上下数值之间相差的值，如0和1相差1；1和4相差3
# 下减上的数值

执行结果：

	one
a	NaN
b	1.0
c	1.0
d	1.0

9、df.shift()

df2-df2.shift(1)
#  效果与{df2.diff()  算数差值}一样，该方法少用，数值广播
# 理解，本身-上一层=diff

	one
a	NaN
b	1.0
c	1.0
d	1.0

10、查找汇总统计describe()

	one	two
a	1.40	NaN
b	7.10	-4.5
c	NaN	NaN
d	0.75	-1.3

添加一列‘there’

df['there'] = ['1','2','3','4']			# 添加一列
df

执行结果：

	one	two	there
a	1.40	NaN	1
b	7.10	-4.5	2
c	NaN	NaN	3
d	0.75	-1.3	4

​ 查找汇总统计

df.describe()       # 查看df中的数据统计情况

执行结果：

	one	two
count	3.000000	2.000000
mean	3.083333	-2.900000
std	3.493685	2.262742
min	0.750000	-4.500000
25%	1.075000	-3.700000
50%	1.400000	-2.900000
75%	4.250000	-2.100000
max	7.100000	-1.300000

11、查看表格信息

df.info


# 执行结果：
<bound method DataFrame.info of     one  two there
a  1.40  NaN     1
b  7.10 -4.5     2
c   NaN  NaN     3
d  0.75 -1.3     4>

对上述中添加there的df进行处理为float

df['there'] = df.there.astype(float)    # 处理为浮点型
df.info			# 查看表格信息


# 执行结果：
<bound method DataFrame.info of     one  two  there
a  1.40  NaN    1.0
b  7.10 -4.5    2.0
c   NaN  NaN    3.0
d  0.75 -1.3    4.0>

12、apply和applymap

df['there'] = pd['there'].apply(lambda x:int())
df.info			# 处理为int类型


# 执行结果为：
<bound method DataFrame.info of     one  two  there
a  1.40  NaN      0
b  7.10 -4.5      0
c   NaN  NaN      0
d  0.75 -1.3      0>

13、选取出数组中每一列/行的最大值，axis=0

df1 = pd.DataFrame(np.random.randn(5,4))
df1

执行结果为：

	0	1	2	3
0	0.321094	-0.204748	0.391695	-0.521649
1	-1.062381	-0.121107	0.751911	2.560299
2	-0.446993	0.546464	0.342765	0.059072
3	0.447356	0.928174	-1.160135	-1.178226
4	-0.997779	-1.837331	-1.876287	-1.685492

df1.apply(lambda x:x.max())   # 选取出每一列的最大值，axis=0


# 执行结果：
0    0.447356
1    0.928174
2    0.751911
3    2.560299
dtype: float64

df1.apply(lambda x:x.max(),axis=1)    # 每一行的最大值，axis=1


# 执行结果：
0    0.391695
1    2.560299
2    0.546464
3    0.928174
4   -0.997779
dtype: float64

df1.applymap(lambda x:'%.2f'%x)   # 精确度，保留几位小数

执行结果：

	0	1	2	3
0	0.32	-0.20	0.39	-0.52
1	-1.06	-0.12	0.75	2.56
2	-0.45	0.55	0.34	0.06
3	0.45	0.93	-1.16	-1.18
4	-1.00	-1.84	-1.88	-1.69

4.9.4、DataFrame排序

• df.sort_index(axis=0,ascending=True) # 索引排序
  • axis指定轴，默认为0轴
  • ascending为排序方式，默认为True表示升序
• df.sort_values(by) # 值排序
  • by指定一列或者多列作为排序键

1、Series默认行升序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yVDxU19h-1658308305495)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170814018.png)]

• 降序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kFN92AT8-1658308305496)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170846162.png)]

2、Series默认列升序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-As2YV61T-1658308305496)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\image-20220720170929526.png)]

3、DataFrame()排序

• 构造df1数组

  	B	C	A
  b	0	1	2
  d	3	4	5
  c	6	7	8
  a	9	10	11

• 行标签排序

  df1.sort_index()
  # 默认axis=0
  

  执行结果：

  	B	C	A
  a	9	10	11
  b	0	1	2
  c	6	7	8
  d	3	4	5

• 列标签排序

  df1.sort_index(axis=1)
  

  执行结果：

  	A	B	C
  b	2	0	1
  d	5	3	4
  c	8	6	7
  a	11	9	10

• 某一行排序

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xr46prfa-1658308305497)(C:\Users\86152\Desktop\文件笔记\pandas学习基础\2022-07-07_103446.png)]

注意：

• by = [col1,col2] 是先给col1排序，当col1有相同值时，col2中按排序顺序再排序

---

函数应用于映射

• df.apply(func,axis=0) # 通过apply将函数运用到列 或者 行
• df.applymap(func) # applymap将函数应用到每个数据上
  | -0.20 | 0.39 | -0.52 |
  | 1 | -1.06 | -0.12 | 0.75 | 2.56 |
  | 2 | -0.45 | 0.55 | 0.34 | 0.06 |
  | 3 | 0.45 | 0.93 | -1.16 | -1.18 |
  | 4 | -1.00 | -1.84 | -1.88 | -1.69 |

4.9.4、DataFrame排序

• df.sort_index(axis=0,ascending=True) # 索引排序
  • axis指定轴，默认为0轴
  • ascending为排序方式，默认为True表示升序
• df.sort_values(by) # 值排序
  • by指定一列或者多列作为排序键

1、Series默认行升序

[外链图片转存中…(img-yVDxU19h-1658308305495)]

• 降序

[外链图片转存中…(img-kFN92AT8-1658308305496)]

2、Series默认列升序

[外链图片转存中…(img-As2YV61T-1658308305496)]

3、DataFrame()排序

• 构造df1数组

  	B	C	A
  b	0	1	2
  d	3	4	5
  c	6	7	8
  a	9	10	11

• 行标签排序

  df1.sort_index()
  # 默认axis=0
  

  执行结果：

  	B	C	A
  a	9	10	11
  b	0	1	2
  c	6	7	8
  d	3	4	5

• 列标签排序

  df1.sort_index(axis=1)
  

  执行结果：

  	A	B	C
  b	2	0	1
  d	5	3	4
  c	8	6	7
  a	11	9	10

• 某一行排序

  [外链图片转存中…(img-Xr46prfa-1658308305497)]

注意：

• by = [col1,col2] 是先给col1排序，当col1有相同值时，col2中按排序顺序再排序

---

函数应用于映射

• df.apply(func,axis=0) # 通过apply将函数运用到列 或者 行
• df.applymap(func) # applymap将函数应用到每个数据上