Pandas基础(全)

引言

Pandas是基于Numpy的库，但功能更加强大，Numpy专注于数值型数据的操作，而Pandas对数值型，字符串型等多种格式的表格数据都有很好的支持。

关于Numpy的基础知识，请查看 Numpy基础(全)

内容介绍

1.数据结构（Series,DataFrame）

2.索引对象

3.索引操作

4.数据运算

5.层次化索引

6.可视化(暂时忽略)

一，数据结构

Pandas 采用了很多Numpy的代码风格，但Pandas是用来处理表格型或异质性数据的，而Numpy更适合处理同质型的数值类数组数据。

Pandas数据结构：Series 和 DataFrame

<1> Series

# Series 是一种一维的数组型对象，它包含了一个值序列（与 Numpy 中的类型相似），并且包含了数据标签，称为索引。

# 事实上纯数值型的Series对象的values属性就是一个Numpy数组。

# 最简单的序列可以仅仅由一个数组构成：

import pandas as pd

import numpy as np

obj = pd.Series([4,7,-5,3])

obj

# print(obj)  # 打印效果和直接输出obj 效果一样


0    4

1    7

2   -5

3    3

dtype: int64


# 在交互式环境中，Series 的字符串表示为：索引在左边，值在右边。

# 1, 默认索引从0开始，可以通过 index属性 和 values属性分别获得Series对象的索引和值：

obj = pd.Series([4,7,-5,3])

obj.index # 与range(4)类似


RangeIndex(start=0, stop=4, step=1)


obj.values


array([ 4,  7, -5,  3], dtype=int64)


# 2, 可以自定义索引来替换默认索引：

obj2=pd.Series([4,7,-5,3],index=['d','b','a','c'])

# obj2.values

# obj2.index

obj2['a']


-5


# 可以使用 Series_obj.index属性，按位置赋值来改变索引：

obj2.index=['m','b','f','d']

obj2


m    4

b    7

f   -5

d    3

dtype: int64


# 3, 对Series对象使用 Numpy 函数或 Numpy 风格的各种操作（如根据布尔型数组进行过滤，与标量相乘，或者应用数学函数），

# 都会保留索引与值之间的连接关系。

obj2[obj2>0] #以布尔型数组进行索引


d    4

b    7

c    3

dtype: int64


obj2*2


d     8

b    14

a   -10

c     6

dtype: int64


np.exp(obj2)  # 计算各元素的以e为底的指数


d      54.598150

b    1096.633158

a       0.006738

c      20.085537

dtype: float64


# 4, 也可以把 Series 看作是一种长度固定且有序的字典，因此在可能会使用字典的上下文中，使用Series来代替字典也是一个好主意。

print('Yes') if 'b' in obj2 else print('No')

print('Yes') if 'e' in obj2 else print('No')


Yes

No


# 5, 如果你已经将数据存放在了Python的字典中，你也可以使用字典来生成一个Series对象：

sdata={'Ohio':35000,'texas':71000,'Oregon':16000,'Utah':1000}

obj3=pd.Series(sdata)  # 产生一个按【键】排好序的字典。

obj3


Ohio      35000

texas     71000

Oregon    16000

Utah       1000

dtype: int64


# 当然，也可以对键重新定义，当新定义的键在原字典中不存在时，Series处理这个缺失值为NaN。

# 当原来的字典中的键不存在于新定义的索引列表中时，这个键值对就会被排除掉。

obj4=pd.Series(sdata,index=["Tom",'Ohio','Ivan','Utah'])

obj4


Tom         NaN

Ohio    35000.0

Ivan        NaN

Utah     1000.0

dtype: float64


# 6, 检验缺失数据：

# pd.isnull(Series_obj)  pd.notnull(Series_obj)  等同于 Series_obj.isnull() Series_obj.notnull()   返回布尔类型 Series对象：

# 既可以作为pandas的顶层函数，也可以作为 Series实例对象调用的方法。

# 在后面的章节中会深入的讨论如何处理缺失数据。

# pd.isnull(obj4)

obj4.isnull()


Tom      True

Ohio    False

Ivan     True

Utah    False

dtype: bool


# pd.notnull(obj4)

pd.notnull(obj4)


Tom     False

Ohio     True

Ivan    False

Utah     True

dtype: bool


# 7, Series的索引自动对齐：

# 因为上面的obj3和obj4有部分索引是一样的，所以我们对这两个Series对象进行操作：

# Series的索引自动对齐功能和数据库的join操作是很相似的。

obj3+obj4


Ivan          NaN

Ohio      70000.0

Oregon        NaN

Tom           NaN

Utah       2000.0

texas         NaN

dtype: float64


# 8, Series_obj.name 属性和 Series_obj.index.name 属性：

# 可以修改这两个属性(默认为None)，他们往往和pandas的其他重要功能集成在一起。

print(obj4.name)

print(obj4.index.name)

obj4.name="population"   # 人口

obj4.index.name="state"  # 州

obj4


None

None

state

Tom         NaN

Ohio    35000.0

Ivan        NaN

Utah     1000.0

Name: population, dtype: float64


# 9, 按索引改变 Series对象的元素值：

# obj = pd.Series([4,7,-5,3],index=['Bob','Steve','Jeff','Ryan'])

obj = pd.Series([4,7,-5,3])

obj.index=['Bob1','Steve1','Jeff1','Ryan1']

obj['Steve1']=10

obj


Bob1       4

Steve1    10

Jeff1     -5

Ryan1      3

dtype: int64

<2> DataFrame

# DataFrame表示矩阵数据表，包含已经排序的列集合，每一列可以是不同的值类型（数值，字符串，布尔值等）。

# 既有行索引，也有列索引。

# 可以被视为共享相同索引的 Series的字典。

# 数据被存储为一个以上的二维块，而不是列表，字典或其他一维数组的集合。

# Note: 尽管 DataFrame是二维的，但可以利用分层索引在DataFrame中展现更高维度的数据。分层索引是pandas中一种更为高级的数据处理特性。

# DataFrame 既可以创建而来，也可以由其他数据类型转化而来。

# 1，创建 DataFrame

# 1）创建 DataFrame:

# 给 pd.DataFrame()传入由长度相等的列表，数组或元组组成的字典，创建DataFrame 对象.

# 字典的键位 DataFrame的列索引。

# DataFrame 构造函数的有效输入:

# 二维数组 2d ndarray                数据矩阵，行列的索引标签是可选参数   1-10）

# 数组，列表，元组,序列构成的字典      每个序列成为 DataFrame 的一列，所有的序列必须长度相等     1-1）至 1-5）

# Numpy 结构化/记录化数组            与数组构成的字典一致

# Series 构成的字典                  每个 Series为一列，Series的索引合并为行索引，也可以显式的传递索引  1-1）至 1-4）

# 字典构成的字典（嵌套字典）          每一个内部字典形成一列，键联合起来形成结果的行索引   1-6）

# 字典或Series构成的列表             列表中的一个元素形成 DataFrame的一行，字典的键 或Series索引联合起来形成 DataFrame的列标签  1-8）1-9)

# 列表或元组构成的列表               与 2d ndarray的情况一致    1-7)

# 其他DataFrame                     如果不显式传递索引，则会使用原 DataFrame 的索引

# Numpy MaskedArray                 与 2d ndarray的情况类似，但隐藏值会在结果DataFrame 中成为 NA/缺失值

# 1-1) pd.DataFrame(dict_ndarrayvalu)

from pandas import Series,DataFrame

import pandas as pd

import numpy as np

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':np.array(['female','female','male','male']),

    'year':np.array([2001,2001,2003,2002]),

    'city':np.array(['北京','上海','广州','深圳'])

}

df=DataFrame(data)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 1-2）pd.DataFrame(dict_listvalue)

data1={

    'name':['张三','李四','王五','小明'],

    'sex':['female','female','male','male'],

    'year':[2001,2001,2003,2002],

    'city':['北京','上海','广州','深圳']

}

df1=DataFrame(data1)

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 1-3）pd.DataFrame(dict_tuplevalue)

data1={

    'name':('张三','李四','王五','小明'),

    'sex':('female','female','male','male'),

    'year':(2001,2001,2003,2002),

    'city':('北京','上海','广州','深圳')

}

df1=DataFrame(data1)

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 1-4）pd.DataFrame(dict_Seriesvalue)

data2={

    'name':pd.Series(['张三','李四','王五','小明']),

    'sex':pd.Series(['female','female','male','male']),

    'year':pd.Series([2001,2001,2003,2002]),

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df02=DataFrame(data2)

df02
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 1-5）pd.DataFrame(dict_mixvalu)

data3={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2001,2003,2002],

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df03=DataFrame(data3)

df03
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 1-6) 使用嵌套字典的数据也可以创建 DataFrame 数据：    外层字典的键为列索引，内层字典的键为行索引

data2={

    'sex':{'张三':'female','李四':'female','王五':'male'},

    'city':{'张三':'北京','李四':'上海','王五':'广州'}

}

# df02=DataFrame(data2,index=['老大','李四','王五'])   # 也可以这样显式地指定行/列索引的顺序或改变行/列数据。

df02=DataFrame(data2,index=['老大','李四','王五'],columns=['sex','city','newcolumn'])

df02
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex city newcolumn
老大 NaN NaN NaN
李四 female 上海 NaN
王五 male 广州 NaN 
# 1-7) 使用列表或元组构成的嵌套列表创建 DataFrame 数据 ，每个内层列表/元组就是一行数据  行，列索引由 DataFrame()提供

# data = [['Alex',10],['Bob',12],['Clarke',13]]

import pandas as pd

data = [('Alex',10),('Bob',12),('Clarke',13)]

df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

Name Age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0 
# 1-8) 使用字典列表创建 DataFrame 数据  ，每个字典都包含了列标签（键）的一行数据（值）

data = [{'name':'Alex','age':10},{'name':'Bob','age':12},{'name':'Clarke','age':13}]

df = pd.DataFrame(data,dtype=float)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0 
# 1-9） 使用Series对象创建 DataFrame 数据，每个Series都包含了列标签（index）的一行数据（值）

data = [pd.Series(['Alex',10],index=['Name','Age']),pd.Series(['Bob',12],index=['Name','Age']),pd.Series(['Clarke',13],index=['Name','Age'])]

df = pd.DataFrame(data,dtype=float)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

Name Age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0 
# 1-10) 使用 2dndarray 创建 DataFrame 数据：

arr2d=np.array([['Alex',10],['Bob',12],['Clarke',13]])

df = pd.DataFrame(arr2d,columns=['name','age'])  # 使用 2dndarray 创建 DataFrame 数据，不能指定 dtype=float，会报错

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name age
0 Alex 10
1 Bob 12
2 Clarke 13 



# 2，可以通过 columns和 index 属性来查看列和行：

df02.columns


Index(['sex', 'city'], dtype='object')


df02.index


Index(['老大', '李四', '王五'], dtype='object')


# 3，DataFrame的指定列索引列表，对列索引进行排序:

# 虽然上面的df都是按创建时的code 顺序对列进行排列的，但由于字典是无序的，所以为了安全起见，我们创建DataFrame时手动指定\修改 列的顺序：

from pandas import DataFrame

import numpy as np

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':np.array(['female','female','male','male']),

    'year':np.array([2001,2001,2003,2002]),

    'city':np.array(['北京','上海','广州','深圳'])

}

df02=DataFrame(data,columns=['name','year','sex','city'])  # 语法

df02
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city
0 张三 2001 female 北京
1 李四 2001 female 上海
2 王五 2003 male 广州
3 小明 2002 male 深圳 
# 4，指定行索引列表（没有指定行索引的情况下，默认的行索引是从0到N-1（N为数据长度））

df03=DataFrame(data,columns=['name','year','sex','city'],index=['a','b','c','d'])  # 语法

df03
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city
a 张三 2001 female 北京
b 李四 2001 female 上海
c 王五 2003 male 广州
d 小明 2002 male 深圳 
# 当指定的【列】索引在传入的data字典中不存在时，将会以缺失值NaN处理：

# 如果少指定了某列，生成的DataFrame对象就不含此列数据。

# 注意，如果多指定了行或少指定了行，就会报错。

df03=DataFrame(data,columns=['name','year','sex','city','job'],index=['a','b','c','d'])  # 语法

df03
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job
a 张三 2001 female 北京 NaN
b 李四 2001 female 上海 NaN
c 王五 2003 male 广州 NaN
d 小明 2002 male 深圳 NaN 
# 5，对 DataFrame的行和列进行索引：

# 5-1）索引 DataFrame 的列返回 Series对象：

# Dataframe_obj[column] 或 Dataframe_obj.column   返回的结果为 Series 对象

# 返回的 Series对象与 DataFrame对象有相同的索引,且 Series的name 属性也会被合理的设置：

df04=DataFrame(data,columns=['name','year','sex','city','job'],index=['张','李','王','马'])

df04['sex']


张    female

李    female

王      male

马      male

Name: sex, dtype: object


sex=df04.sex

sex


张    female

李    female

王      male

马      male

Name: sex, dtype: object


# 5-2) 索引 DataFrame 的行返回 Series对象：

# 注意语法： dataframe_obj.loc[line_index]  # DataFrame对象的特殊属性 loc

df04.loc['李']


name        李四

year      2001

sex     female

city        上海

job        NaN

Name: 李, dtype: object


# 5-3）通过列索引修改/赋值/创建 此列元素：

df04['job']='Data Analysis' # 将一个值赋值给一列

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job
张 张三 2001 female 北京 Data Analysis
李 李四 2001 female 上海 Data Analysis
王 王五 2003 male 广州 Data Analysis
马 小明 2002 male 深圳 Data Analysis 
df04['job']=np.arange(4.)  # 将一个与列等长度的ndarray数组赋值给一列

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job
张 张三 2001 female 北京 0.0
李 李四 2001 female 上海 1.0
王 王五 2003 male 广州 2.0
马 小明 2002 male 深圳 3.0 
df04['job']=['Data Analysis']*4  # 将一个与列等长度的列表赋值给一列

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job
张 张三 2001 female 北京 Data Analysis
李 李四 2001 female 上海 Data Analysis
王 王五 2003 male 广州 Data Analysis
马 小明 2002 male 深圳 Data Analysis 
val=pd.Series(['Data Analysis dev','Data Analysis im','Data Analysis ba'],index=['马','李','张'])

df04['job']=val  # 将一个长度<=列长度的 Series对象赋值给一列， 缺失值处理为NAN，按照 DataFrame的索引排列

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job
张 张三 2001 female 北京 Data Analysis ba
李 李四 2001 female 上海 Data Analysis im
王 王五 2003 male 广州 NaN
马 小明 2002 male 深圳 Data Analysis dev 
val=pd.Series(['band 6A','band 8B','band 7B'],index=['马','李','王'])

df04['band']=val  # 如果列索引并不存在，创建一个新的列。（无论赋值的内容是列表，Series或值）

df04

# 说明了 从 DataFrame里选取的列是数据的视图，不是拷贝。对 Series的修改会映射到 DataFrame里。
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name year sex city job band
张 张三 2001 female 北京 Data Analysis ba NaN
李 李四 2001 female 上海 Data Analysis im band 8B
王 王五 2003 male 广州 NaN band 7B
马 小明 2002 male 深圳 Data Analysis dev band 6A 
# 6，del 关键字 删除DataFrame的列

# 像字典中删除键一样

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':np.array(['female','female','male','male']),

    'year':np.array([2001,2001,2003,2002]),

    'city':np.array(['北京','上海','广州','深圳'])

}

df04=DataFrame(data)

# step1 先增加一列，再删掉：

df04['new']=df04.sex=='female'    # Note:df04.new 的语法 无法用来创建新的列,也无法用来删除指定的列

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city new
0 张三 female 2001 北京 True
1 李四 female 2001 上海 True
2 王五 male 2003 广州 False
3 小明 male 2002 深圳 False 
del df04['new']

df04.columns


Index(['name', 'sex', 'year', 'city'], dtype='object')


# 7，DataFrame数据的复制：

# 要显式地使用Series的copy方法：

series_copy=df04['sex'].copy()

series_copy


0    female

1    female

2      male

3      male

Name: sex, dtype: object


series_copy[2]='female'  # 注意是 series_copy[2] 而不是 series_copy['2'],如果用后者，相当于创建一个新的元素。

series_copy


0    female

1    female

2    female

3      male

Name: sex, dtype: object


df04  # 对 series_copy 的修改不会影响原来的 dataframe
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 8，DataFrame 的转置

# 语法： 类似 Numpy, dataframe_obj.T

df04.T
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

0 1 2 3
name 张三 李四 王五 小明
sex female female male male
year 2001 2001 2003 2002
city 北京 上海 广州 深圳 
df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 9，给列索引和行索引的 name 属性赋值：

df04.index.name='Name'

df04.columns.name='Infor'

df04
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

Infor name sex year city
Name
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 10，DataFrame的 index, column, values属性

df04.index  # 一维数组


RangeIndex(start=0, stop=4, step=1, name='Name')


df04.columns  # 一维数组


Index(['name', 'sex', 'year', 'city'], dtype='object', name='Infor')


df04.values  # 二维数组


array([['张三', 'female', 2001, '北京'],

       ['李四', 'female', 2001, '上海'],

       ['王五', 'male', 2003, '广州'],

       ['小明', 'male', 2002, '深圳']], dtype=object)


# df04['new']=['12','abc',12,'NaN']

df04['new']=pd.Series(['Data Analysis dev','Data Analysis im','Data Analysis ba'],index=[0,1,2])

df04.values


array([['张三', 'female', 2001, '北京', 'Data Analysis dev'],

       ['李四', 'female', 2001, '上海', 'Data Analysis im'],

       ['王五', 'male', 2003, '广州', 'Data Analysis ba'],

       ['小明', 'male', 2002, '深圳', nan]], dtype=object)

二，索引对象

#以下按照《零基础 Python数据分析》来学习。

# DataFrame的索引也是对象，这些对象有自己的方法和属性

# pandas 中的索引对象是用于存储轴标签和其他元数据的 （例如轴名称或标签）。

# Series 或 DataFrame 时，你所使用任意数组或标签序列都可以在内部转换为索引对象。

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2001,2003,2002],

    'city':('北京','上海','广州','深圳')

}

df=DataFrame(data)

# 1，索引对象

df.index


RangeIndex(start=0, stop=4, step=1)


df.columns


Index(['name', 'sex', 'year', 'city'], dtype='object')


# 2， 索引对象不可更改，强改会报错：

# index=df.index

col = df.columns

# index[1]=0

col[1]='a'


---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-144-daed13b54382> in <module>

      3 col = df.columns

      4 # index[1]=0

----> 5 col[1]='a'

~\anaconda3\envs\data_analysis\lib\site-packages\pandas\core\indexes\base.py in __setitem__(self, key, value)

   3908

   3909     def __setitem__(self, key, value):

-> 3910         raise TypeError("Index does not support mutable operations")

   3911

   3912     def __getitem__(self, key):

TypeError: Index does not support mutable operations


# 3，索引对象类似于数组，其功能类似于一个固定大小的集合

df.index.name='infor item'

df.columns.name='details'

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

details name sex year city
infor item
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
'sex' in df.columns


True


2 in df.index


True

三，索引操作

# (1)讲解 Series 和 DataFrame 的索引操作的方法

# (2)与 Excel 数据类比，讲解 DataFrame 数据的选取与操作

# 1，重新索引：

# 1-1）Series 重新索引： s_obj.reindex(新索引列表[,method='ffill'])  返回一个新的 Series对象，不改变原来的 Series.

# 其中 method 参数可以缺省，缺省时，新索引列表中新引入的索引对应的元素值为 NaN,

# method='ffill'或'pad' 指元素值与前后一行相同（向前填充），method='bfill' 或'pad' 指元素值与前一行相同（向后填充）。

s_obj=Series([1,2,3,4],index=['a','c','d','f'])

s_obj


a    1

c    2

d    3

f    4

dtype: int64


s_obj2=s_obj.reindex(['a','c','m','d','e'])   # 没有使用原来的索引 c,新引入了索引 e

s_obj2


a    1.0

c    2.0

m    NaN

d    3.0

e    NaN

dtype: float64


# reindex重新索引后，引入原 Series没有的索引时，可用 method='ffill',method='bfill' 进行填充。

# 填充规则：新引入的索引与原索引进行字符排序，按字符顺序的先后 进行向前或向后填充。

s_obj3=s_obj.reindex(['a','b','m','d','e'],method='ffill')  # 向后填充， 用a对应的值向后填充b,用 f对应的值向后填充 m

s_obj3


a    1

b    1

m    4

d    3

e    3

dtype: int64


s_obj4=s_obj.reindex(['a','b','m','d','e'],method='bfill')  # 向前填充。 用 c对应的值向前填充 b, m之后的值（NaN)向前填充m

s_obj4


f    4.0

b    2.0

m    NaN

d    3.0

e    4.0

dtype: float64


s_obj  # 不改变原来的 Series对象


a    1

b    2

c    3

d    4

dtype: int64


# 1-2）DataFrame 的重新索引：

# 对于 DataFrame 数据来说，行和列索引都可以被重新索引：

import numpy as np

import pandas as pd

from pandas import DataFrame,Series

df=DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['name','id','sex'])

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name id sex
a 0 1 2
c 3 4 5
d 6 7 8 
# 重新索引行：

df2=df.reindex(['a','b','c','d'])

# df2=df.reindex(index=['a','n','c','d'])        # 重新指定行索引时 index关键字 可以省略

df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name id sex
a 0.0 1.0 2.0
b NaN NaN NaN
c 3.0 4.0 5.0
d 6.0 7.0 8.0 
# 重新索引列：

gender=df2.sex

df3=df.reindex(columns=['name','id','gender','job'],fill_value=[0,1,2])   # 重新指定列索引要使用 columns关键字

df3['gender']=gender

df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name id gender job
a 0 1 2.0 [0, 1, 2]
c 3 4 5.0 [0, 1, 2]
d 6 7 8.0 [0, 1, 2] 
# 总结 reindex 函数的参数使用说明：

index       用于索引的新序列

method      填充缺失值方法  method='bfill' method='ffill'

fill_value  缺失值替代值  fill_value 将接收到的值assign给每一个缺失的元素，并不解包。

limit       最大填充量 （遇到再看）


# 2，更换索引：（针对 DataFrame） 返回新的 DataFrame, 不改变原来的 DataFrame

# set_index('某个列索引')    # 使用某一列作为行索引,通常用来替代默认的行索引

import numpy as np

import pandas as pd

from pandas import DataFrame,Series

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2001,2003,2002],

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df=DataFrame(data)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
df2=df.set_index('name')  # 使用 name 这列来替代默认行索引，'name'变成了行索引的index.name 属性值。

print(df2.index.name,df2.columns.name)

df2

# df3=df2.set_index('sex')   此时会将 将sex这列作为新返回的 d3的行索引，name列不存在于df3中。


name None
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year city
name
张三 female 2001 北京
李四 female 2001 上海
王五 male 2003 广州
小明 male 2002 深圳 
df3=df2.reset_index()

print(df3.index.name,df3.columns.name)

df3


None None
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2001 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
# 对 DataFrame行索引的排序，行索引会随之排序，但excel表格里不会.

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2000,2003,2002],

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df=DataFrame(data)

df2=df.sort_values(by='year')  # 不改变原 DataFrame,返回新的 DataFrame

df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
1 李四 female 2000 上海
0 张三 female 2001 北京
3 小明 male 2002 深圳
2 王五 male 2003 广州 
# 此时，如果我们想得到像excel那样，数据排序之后，行号不跟随排序，依然是0，1，2...，可以：

df3=df2.reset_index()  #将默认行索引变为 列, 重新生成一个新的默认行号：

df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

index name sex year city
0 1 李四 female 2000 上海
1 0 张三 female 2001 北京
2 3 小明 male 2002 深圳
3 2 王五 male 2003 广州 
df4=df2.reset_index(drop=True)  # 这样既可以生成一个新的默认行索引，又会删除多余的行索引。

df4
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 李四 female 2000 上海
1 张三 female 2001 北京
2 小明 male 2002 深圳
3 王五 male 2003 广州 
# 3，索引和选取

# 通过索引来选取数据是 Series和 DataFrame 选取数据的手段（excel可以鼠标选取，VBA可以code指定）

# 3-1）Series 的数据选取：

# 3-1-1） Series_obj[n]   # n是 0 到 Series_obj.size-1 范围的数。

# 3-1-2） Series_obj(行索引标签)

# 对选取元素的值的更改，会影响到原来的 Series或 DataFrame。

from pandas import Series,DataFrame

Series_obj=Series([1,2,1,5],index=['i1','i2','i3','i4'])

print(Series_obj[2])

print(Series_obj['i3'])   # 单元素索引返回单个值

Series_obj[['i1','i4']]   # 多元素索引 返回序列

Series_obj[:'i1']         # 切片索引  注意，与 Python列表不同之处： 列表是含左不含右， Series是都包含。  返回序列

Series_obj[:'i3']         # 切片索引  注意，与 Python列表不同之处： 列表是含左不含右， Series是都包含。  返回序列

Series_obj[Series_obj==2] # 布尔索引 无论符合条件的结果是单个元素还是多个元素，返回的都是序列

Series_obj[Series_obj<2]  # 布尔索引 无论符合条件的结果是单个元素还是多个元素，返回的都是序列

Series_obj[2]=6           # 对选取元素的值的更改，会影响到原来的 Series或 DataFrame

Series_obj


1

1

i1    1

i2    2

i3    6

i4    5

dtype: int64


# 3-2）DataFrame 的数据选取：

# 选取行，选取列，选取行列子集

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2000,2003,2002],

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df=DataFrame(data)

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2000 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
df2=df.set_index('name')

df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year city
name
张三 female 2001 北京
李四 female 2000 上海
王五 male 2003 广州
小明 male 2002 深圳 
# df2['王五']  # 报错

# df2[1]  # 报错

# df.loc[df.index[0,2], ['name','city']]  #报错

# df.loc[df.index[[0,2]], df.columns['name','city']]  #报错

# df.loc[df.index[0:2], ['name','city']]    #可以

# df.loc[df.index[[0,2]], ['name','city']]  #可以


---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-155-c741d5a2df48> in <module>

      5 # df.loc[df.index[0:2], ['name','city']]    #可以

      6 # df.loc[df.index[[0,2]], ['name','city']]  #可以

----> 7 df.loc[df.index[[0,2]], df.columns['name','city']]  #可以

~\anaconda3\envs\data_analysis\lib\site-packages\pandas\core\indexes\base.py in __getitem__(self, key)

   3939

   3940         key = com.values_from_object(key)

-> 3941         result = getitem(key)

   3942         if not is_scalar(result):

   3943             if np.ndim(result) > 1:

IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices


# DataFrame 行列 选取总结：

# df2['王五']   # 报错

# df2[1]        # 报错

# 多行：

# df2.[['张三','王五']]  # 报错

# df2.[[1,3]]           # 报错

# 为了防止弄混，DataFrame选取多行时，一律使用 loc和 iloc：（当使用切片时，不使用 loc iloc也是允许的）

# 单行：

df.loc['王五']

df.iloc[1]  

# 多行：

df.iloc[0:2]

df.loc['李四':'王五']

df.loc[['张三','王五']]

df.iloc[[1,3]] 

# 单列：

df.year     # 按属性选取

df['year']  # 按列索引标签选取

# 多列：(不可使用切片)

df[['year','name']]

# 选取行列子集：

df.loc[df.index[0:2], ['name','city']]

df.loc[df.index[[0,2]], ['name','city']]

df.iloc[df.index[[0,2]], [0,2]]

# 布尔选择

# 与数组布尔型索引相似：！=  ~  & |

df['sex']=='female'      # 对某一列进行条件判断，返回布尔型 Series

df[df['sex']=='female']  # 返回符合条件的行列子集

df[df['sex']=='female' & df['year']==2001] # 必须使用括号

df[(df['sex']=='female') & ~(df['year']==2001)]

df[(df['sex']=='female') & (df['year']!=2001)]

df[(df['sex']=='female') | (df['year']==2002)] 

# 对索引出来的数据进行修改，会影响到原来的数据结构

df[df['sex']=='female'] ='haha'

df['year'] = 2010

# 要想索引出来的数据独立使用，不影响原来数据结构，就要使用 .copy()

df2=df[df['sex']=='female'].copy()

df2.year=2030


df2=df[df['sex']=='female'].copy()

df2.year=2030

df2

# df

# df['year'] = 2010

# df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2030 北京
1 李四 female 2030 上海 
# 4，DataFrame的增，删，改，查（即索引）-----操作行和列

# 不会改变原来的 DataFrame,返回一个新的 DataFrame

# 4-1）查  上面的3-2）已经涵盖

# 4-2)增

# 4-2-1）对行的增加： df.append(new_data,ignore_index=True)    增加一行数据

import numpy as np

from pandas import DataFrame,Series

import pandas as pd

data={

    'name':np.array(['张三','李四','王五','小明']),

    'sex':('female','female','male','male'),

    'year':[2001,2000,2003,2002],

    'city':pd.Series(['北京','上海','广州','深圳'])

}

df=DataFrame(data)

new_data={

    'name':"Tom",

    'sex':'male',

    'year':2007,

    'city':'南京'

}

df2=df.append(new_data,ignore_index=True)   # 返回一个新的 DataFrame, 不影响原来的。

df2

# df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2000 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳
4 Tom male 2007 南京 
# 4-2-2）对列的增加删除和修改在 《一，创建 DataFrame  4-3）通过列索引修改/赋值/创建 此列元素》 一节


# 4-3)删

# 4-3-1) 删除行：new_df=df.drop(2)   针对行索引是数字的有效。  不指定axis时，默认axis=0

new_df=df2.drop(4)

new_df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

name sex year city
0 张三 female 2001 北京
1 李四 female 2000 上海
2 王五 male 2003 广州
3 小明 male 2002 深圳 
new_df2=new_df.set_index('name')

new_df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year city
name
张三 female 2001 北京
李四 female 2000 上海
王五 male 2003 广州
小明 male 2002 深圳 
# new_df3=new_df2.drop(1)      # 报错， 当行索引变为name时，数字参数不好用。

new_df3=new_df2.drop('李四',axis=0)   # 不指定 axis时，默认axis=0    new_df2.drop('李四')

new_df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year city
name
张三 female 2001 北京
王五 male 2003 广州
小明 male 2002 深圳 
# 4-3-2) 删除列：new_df=df.drop('city',axis=1)

# 或

# del df['city'](会影响原数据)

new_df4=new_df3.drop('city',axis=1)

new_df4

# new_df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year city
name
张三 female 2001 北京
王五 male 2003 广州
小明 male 2002 深圳 
del new_df3['city']  # 会影响原数据

new_df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

sex year
name
张三 female 2001
王五 male 2003
小明 male 2002 
# 4-4)改  当参数inplace=True时，会原地修改，当inplace=False或缺省时，不会影响原数据，返回一个新的数据。

# 这里的修改是指 对行列索引标签的修改，通过 df.rename()函数，可完成由于某些原因导致的标签录入错误的问题：

# new_df4=new_df3.rename(index={'王五':'王老五','小明':'马六'},columns={'sex':'gender'})

# new_df4

new_df3.rename(index={'王五':'王老五','小明':'马六'},columns={'sex':'gender'},inplace=True) # 可在原数据上进行修改

new_df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

gender year
name
张三 female 2001
王老五 male 2003
马六 male 2002

四，数据运算(重点内容)

# 1，pandas 算术运算 

# 参与运算的 各个 Series 的size大小任意。

# 参与运算的 各个 DataFrame 的行数必须相同。

# 1-1）Series 算术运算

# 有共同索引的元素才会进行算术运算，如果没有，则引入 NaN --对齐操作

S1=Series([2.1,5,-3,0.2,0.3],index=['a','c','d','f','g'])

S2=Series([3.5,1.5,-2,0.5],index=['a','b','d','e'])  # 共同索引为 'a','d'

S1+S2


a    5.6

b    NaN

c    NaN

d   -5.0

e    NaN

f    NaN

g    NaN

dtype: float64


# 1-2）DataFrame 算术运算

# 对于 DataFrame数据，对齐操作会同时发生在行和列上

df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])

df2=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','coco'],columns=['a','b','d'])

df1+df2  # 运算返回的结果包含了参与运算的 df的所有的列,
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a b c d
apple 0.0 2.0 NaN NaN
banana 6.0 8.0 NaN NaN
coco NaN NaN NaN NaN
tea NaN NaN NaN NaN 
# 1-3）DataFrame 和 Series的 算术运算：

# 要求 Series的【行索引】和 DataFrame的【列索引】要一致。

#

S1=Series([2,3,4],index=['a','b','c'])

df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])

df1+S1 # df的 a列+2 b列+3，c列+4
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a b c
apple 2 4 6
banana 5 7 9
tea 8 10 12 
df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])

s1=df1.loc['apple']  # 取 DtaFrame的单行，这样取得的 Series的索引为 DataFrame的列索引

s1


a    0

b    1

c    2

Name: apple, dtype: int32


df1+s1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a b c
apple 0 2 4
banana 3 5 7
tea 6 8 10 
# 2, 函数应用与映射

# 自定义函数对数据进行较为复杂的函数运算，然后应用到 pandas数据中

# 有三种使用自定义函数的datafrom方法： 参数 f 为自定义函数,也可以是lambda表达式

# 6-1）se.map(f) 函数              将函数套用在每个 Series 元素上

# 6-2）df.aplly(f,axis=1)函数      将函数套用在 DataFrame的行与列上,若 axis缺省，则默认axis=0

# 6-3）df.applymap(f)函数          将函数套用在 DataFrame的每个元素上


# 2-1）df.map(f) 函数    用在 Series元素上

# 使用 map函数，去掉‘元’字

data={

    'fruit':['apple','orange','grape','banana'],

    'price':['25元','42元','35元','15元']

}

df1=DataFrame(data)

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

fruit price
0 apple 25元
1 orange 42元
2 grape 35元
3 banana 15元 
def removeyuan(x):

    return x.split('元')[0]  # 取‘25元’中的‘25’

# df1['price']=df1['price'].map(removeyuan)  # df1['price'] 是序列

# 可以使用 lambda表达式代替 f:

df1['price']=df1['price'].map(lambda x:x.split('元')[0])     # 放在map()里 x在这里代表 元素

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

fruit price
0 apple 25
1 orange 42
2 grape 35
3 banana 15 
# 2-2）df.apply(f) 函数

df2=DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['linux','win','mac'])

df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a b c
linux 2.289954 -0.86051 -0.419287
win 0.079616 -2.25940 -1.128554
mac -0.828268 -0.35262 1.106663 
f=lambda x:x.max()-x.min()  # 放在apply()里 x在这里代表 行或列

df2.apply(f)


a    3.118222

b    1.906779

c    2.235217

dtype: float64


df2.apply(f,axis=1)


linux    3.150464

win      2.339016

mac      1.934931

dtype: float64


# 2-3）df.applymap(f) 函数

df2.applymap(lambda x:'%.2f'%x)  # 保留小数点两位
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a b c
linux 2.29 -0.86 -0.42
win 0.08 -2.26 -1.13
mac -0.83 -0.35 1.11 
# 3, 排序

# 排序不会影响原来的 数据，返回新的数据。

# 3-1）Series  se.sort_index(ascending=False)

# 对索引进行排序  ascending缺省时默认升序，ascending=False为降序

s1=Series([1,-1,3,2],index=['b','a','d','c'])

s1


b    1

a   -1

d    3

c    2

dtype: int64


s1.sort_index()  # 升序

s1.sort_index(ascending=False)  # 降序

# s1 # 不会影响原来数据


d    3

c    2

b    1

a   -1

dtype: int64


# 3-2) Series  se.sort_values(ascending=False)

# 对value进行排序  ascending缺省时默认升序，ascending=False为降序

s1=Series([2,-1,3,5],index=['b','a','d','c'])

s1.sort_values()

s1.sort_values(ascending=False)


c    5

d    3

b    2

a   -1

dtype: int64


# 3-3) DataFrame  df.sort_index(asix=1,ascending=False)  对指定轴的 索引 进行排序

# 当axis缺省时，默认为 axis=0, 当 ascending缺省时，默认ascending=True

df1=DataFrame(np.random.randn(3,3),columns=['a','d','c'],index=['linux','win','mac'])

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a d c
linux 0.282841 -1.783628 -0.685621
win -0.548632 0.754350 0.047237
mac -0.521260 -0.089012 -0.711214 
df1.sort_index(axis=0,ascending=True)

# df1.sort_index(axis=1)
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a d c
linux 0.282841 -1.783628 -0.685621
mac -0.521260 -0.089012 -0.711214
win -0.548632 0.754350 0.047237 
# 3-4) DataFrame  df.sort_values(by='d',ascending=False)  对指定列的值进行排序

# 当 ascending缺省时，默认ascending=True

df1.sort_values(by='d',ascending=False)
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a d c
win -0.548632 0.754350 0.047237
mac -0.521260 -0.089012 -0.711214
linux 0.282841 -1.783628 -0.685621 
# 4, 汇总与统计

# df.sum(axis=0)

# axis=0 或 axis缺省 表示对每一列分别求和，axis=1表示对行求和，返回 Series数据。

# df.describe() 对每个数值型【列】进行统计，用于对数据的初步观察时使用，得到一个关于最值，平均值，标准差等信息的 DataFrame.

df=DataFrame(np.random.randn(3,3),columns=['a','d','c'])

df
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a d c
0 0.871841 1.235904 0.173434
1 -2.764356 -0.641077 -0.107045
2 0.182462 0.602054 -1.230373 
df.sum(axis=1)

df.sum()


a   -1.710053

d    1.196880

c   -1.163983

dtype: float64


df.describe()
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

a d c
count 3.000000 3.000000 3.000000
mean -0.570018 0.398960 -0.387994
std 1.931360 0.954830 0.742878
min -2.764356 -0.641077 -1.230373
25% -1.290947 -0.019512 -0.668709
50% 0.182462 0.602054 -0.107045
75% 0.527151 0.918979 0.033195
max 0.871841 1.235904 0.173434 
# 5, 唯一值与值计数  重点内容

# 都是针对 Series 对象而言的 （DataFrame的行和列也是 Series）

# series.unique() 获取不重复元素组成的 ndarray数组

s1=Series([2,-1,3,2,1,4,5,3,5])

s1.unique()


array([ 2, -1,  3,  1,  4,  5], dtype=int64)


# series.value_counts() 可以统计每个值出现的次数  返回以序列元素为索引，以次数为元素的 Series.#

s1.value_counts()


 5    2

 3    2

 2    2

 4    1

 1    1

-1    1

dtype: int64


# 对于 DataFrame的行和列

data={

    'fruit':['apple','orange','apple','banana'],

    'price':[25,42,25,15],

    'name':['myapple','orange','apple','bolo']

}

df1=DataFrame(data)

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

fruit price name
0 apple 25 myapple
1 orange 42 orange
2 apple 25 apple
3 banana 15 bolo 
df1['fruit'].unique()


array(['apple', 'orange', 'banana'], dtype=object)


df1['fruit'].value_counts()


apple     2

orange    1

banana    1

Name: fruit, dtype: int64


df1.iloc[2].unique()


array(['apple', 25], dtype=object)


df1.iloc[2].value_counts()


apple    2

25       1

Name: 2, dtype: int64

五，层次化索引

# 层次化索引就是轴上有多个级别索引，即索引是个多维列表，这里只讨论二维列表。

# 1，Series 数据的层次化索引创建：

series_obj=Series(np.random.randn(9),index=[['one','one','one','two','two','two','three','three','three'],['a','b','c']*3])

series_obj


one    a   -0.913606

       b    1.258280

       c    0.430108

two    a    0.366005

       b   -1.821770

       c    1.135238

three  a    0.131614

       b   -0.407047

       c    0.576246

dtype: float64


series_obj['two']   # 对层次化序列的外层索引


a    0.366005

b   -1.821770

c    1.135238

dtype: float64


series_obj[:,'a']   # 对层次化序列的内层索引   所有行的 a 行


one     -0.913606

two      0.366005

three    0.131614

dtype: float64


series_obj['two','a']   # 对层次化序列的内层索引   two行的 a 行


0.36600524764982423


series_obj.index   # 该索引对象为 MulitiIndex


MultiIndex([(  'one', 'a'),

            (  'one', 'b'),

            (  'one', 'c'),

            (  'two', 'a'),

            (  'two', 'b'),

            (  'two', 'c'),

            ('three', 'a'),

            ('three', 'b'),

            ('three', 'c')],

           )


# 2，DataFrame 数据的层次化索引创建：

# 对于 DataFrame，行和列都可以为层次化索引：

df1=DataFrame(np.arange(16).reshape(4,4),index=[['one','one','two','two'],['a','b','a','b']])

df1
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

0 1 2 3
one a 0 1 2 3
b 4 5 6 7
two a 8 9 10 11
b 12 13 14 15 
df2=DataFrame(np.arange(16).reshape(4,4),columns=[['one','one','two','two'],['a','b','a','b']])

df2
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

one two
a b a b
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15 
df3=DataFrame(np.arange(16).reshape(4,4),index=[['one','one','two','two'],['a','b','a','b']],

              columns=[['apple','apple','orange','orange'],['size','price','size','price']])

df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
one a 0 1 2 3
b 4 5 6 7
two a 8 9 10 11
b 12 13 14 15 
df3['apple']
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

size price
one a 0 1
b 4 5
two a 8 9
b 12 13 
df3['apple','size']  # 返回从层次化索引序列


one  a     0

     b     4

two  a     8

     b    12

Name: (apple, size), dtype: int32


df3.loc['one']
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
a 0 1 2 3
b 4 5 6 7 
df3.loc['one','a']  # 返回层次化索引序列


apple   size     0

        price    1

orange  size     2

        price    3

Name: (one, a), dtype: int32


# 3，重排分级顺序

# 用到再细研究

# 通过 swaplevel 方法可以对层次化索引进行重排：

df3
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
one a 0 1 2 3
b 4 5 6 7
two a 8 9 10 11
b 12 13 14 15 
df3.swaplevel(0,1)
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
a one 0 1 2 3
b one 4 5 6 7
a two 8 9 10 11
b two 12 13 14 15 
# 4，对层次化索引的 pandas 数据进行汇总统计

# 对层次化索引的 pandas 数据进行汇总统计时，可以通过 level 参数指定在某层次上进行汇总统计。

# sum()的参数 level=0 表示按相同外层索引的所有子行或子列相加，level=1 表示按相同内层索引的行或列进行求和。

# 层次化索引的用途在后面会详细讲解。

df3.sum(level=0,axis=0)  # 表示按相同外层索引的所有子行或子列相加  one 的 a+b  two 的 a+b
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
one 4 6 8 10
two 20 22 24 26 
df3.sum(level=1,axis=0)  # 表示按相同内层索引的行或列进行求和   one和two的 a+a , b+b
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead tr th { text-align: left }

apple orange
size price size price
a 8 10 12 14
b 16 18 20 22 
df3.sum(level=0,axis=1)  # 表示按相同外层索引的所有子行或子列相加
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

apple orange
one a 1 5
b 9 13
two a 17 21
b 25 29 
df3.sum(level=1,axis=1)  # 表示按相同内层索引的行或列进行求和
.dataframe tbody tr th:only-of-type { vertical-align: middle }
{ vertical-align: top }
.dataframe thead th { text-align: right }

size price
one a 2 4
b 10 12
two a 18 20
b 26 28

六，可视化(暂时忽略)

下一篇将讲述 pandas对外部数据的读取，处理和存储。

Pandas_基础_全的更多相关文章

  1. python基础_格式化输出（%用法和format用法）(转载)

    python基础_格式化输出(%用法和format用法) 目录 %用法 format用法 %用法 1.整数的输出 %o -- oct 八进制%d -- dec 十进制%x -- hex 十六进制 &g ...

  2. 算法基础_递归_求杨辉三角第m行第n个数字

    问题描述: 算法基础_递归_求杨辉三角第m行第n个数字(m,n都从0开始) 解题源代码(这里打印出的是杨辉三角某一层的所有数字,没用大数,所以有上限,这里只写基本逻辑,要符合题意的话,把循环去掉就好) ...

  3. MySQL基础----py全栈

    目录 MySQL基础----py全栈 一.引言 1.什么是数据? 2.什么是数据库(DB)? 3.什么是数据库管理系统(DBMS)? 4.什么是数据库系统? 5.数据库管理系统由来 6.什么是数据模型 ...

  4. Java基础16：Java多线程基础最全总结

    Java基础16:Java多线程基础最全总结 Java中的线程 Java之父对线程的定义是: 线程是一个独立执行的调用序列,同一个进程的线程在同一时刻共享一些系统资源(比如文件句柄等)也能访问同一个进 ...

  5. Flutter实战视频-移动电商-05.Dio基础_引入和简单的Get请求

    05.Dio基础_引入和简单的Get请求 博客地址: https://jspang.com/post/FlutterShop.html#toc-4c7 第三方的http请求库叫做Dio https:/ ...

  6. Flutter实战视频-移动电商-08.Dio基础_伪造请求头获取数据

    08.Dio基础_伪造请求头获取数据 上节课代码清楚 重新编写HomePage这个动态组件 开始写请求的方法 请求数据 .但是由于我们没加请求的头 所以没有返回数据 451就是表示请求错错误 创建请求 ...

  7. Flutter实战视频-移动电商-60.购物车_全选按钮的交互效果制作

    60.购物车_全选按钮的交互效果制作 主要做全选和复选框的这两个功能 provide/cart.dart 业务逻辑写到provide里面 先持久化取出来字符串,把字符串编程list.循环list ca ...

  8. [Zlib]_[0基础]_[使用zlib库压缩文件]

    场景: 1. WIndows上没找到系统提供的win32 api来生成zip压缩文件, 有知道的大牛麻烦留个言. 2. zlib比較经常使用,编译也方便,使用它来做压缩吧. MacOSX平台默认支持z ...

  9. DL基础补全计划(一)---线性回归及示例（Pytorch，平方损失）

    PS:要转载请注明出处,本人版权所有. PS: 这个只是基于<我自己>的理解, 如果和你的原则及想法相冲突,请谅解,勿喷. 前置说明   本文作为本人csdn blog的主站的备份.(Bl ...

随机推荐

  1. 用C写一个简单的推箱子游戏（二）

    下面接着上一篇随笔<用C写一个简单的推箱子游戏(一)>来写 tuidong()函数是用来判断游戏人物前方情况的函数,是推箱子游戏中非常重要的一个函数,下面从它开始继续介绍推箱子的小程序怎么 ...

  2. 【4】进大厂必须掌握的面试题-Java面试-jdbc

    1.什么是JDBC驱动程序? JDBC驱动程序是使Java应用程序与数据库进行交互的软件组件.JDBC驱动程序有4种类型: JDBC-ODBC桥驱动程序 本机API驱动程序(部分为Java驱动程序) ...

  3. ok6410 3.0.1内核调用V4L接口出错解决方法(转)

    在做视频监控项目,以前一直用的是2.6.36的内核,一直很正常,但是这几天换3.0.1内核,启动程序,却出现了错误,如下: ./test_usb_camera XXXXXXXXXXXXXXXXXXXX ...

  4. java中的t怎么用

    <T> T表示返回值是一个泛型,传递啥,就返回啥类型的数据,而单独的T就是表示限制你传递的参数类型,这个案例中,通过一个泛型的返回方式,获取每一个集合中的第一个数据, 通过返回值<T ...

  5. Lock、Synchronized锁区别解析

    上篇博文在讲解 ConcurrentHashMap 时说到 1.7 中 put 方法实现同步的方式是使用继承了 ReentrantLock 类的 segment 内部类调用 lock 方法实现的,而在 ...

  6. k8s-命令创建service

    查看命令帮助 [root@master kubernetes]# kubectl create service -h Create a service using specified subcomma ...

  7. PHP-FPM包的安装与配置 转

    实验环境:CentOS7 [root@~ localhost]#yum -y install php-fpm php-fpm包:用于将php运行于fpm模式 #在安装php-fpm时,一般同时安装如下 ...

  8. Linux运维学习第三周记

    日落狐狸眠冢上 夜归儿女笑灯前 人生有酒须当醉 一滴何曾到九泉 愿醉卧沙场可未有匹夫之勇. 第三周学记 第三周主要学习正则表达式和Shell编程 1.正则表达式基本字符 2.扩展正则表达式 3.gre ...

  9. CentOS 8 关闭防火墙

    SELINUX=disabled vim /etc/selinux/config systemctl disable firewalld.service

  10. JDK源码阅读-------自学笔记(二十四)(java.util.LinkedList 再探 自定义讲解)

    一.实现get方法 1.一般思维实现思路 1).将对象的值放入一个中间变量中. 2).遍历索引值,将中间量的下一个元素赋值给中间量. 3).返回中间量中的元素值. 4).示意图 get(2),传入角标 ...