python—数据分析(二)_dlsvaluereshape = reshape(dlsvalue, size(dlsvalue,

Series和DataFrame中数据的基本功能：

1. reindex方法是创建一个新对象，其数据对Series和DataFrame的新索引，它们的主要区别在DataFrame可以对index或columns使用reindex方法。

• Series的reindex用法

import pandas as pd
import numpy as np
from pandas import Series, DataFrame
frame = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
# frame
# 会根据新索引对原Series的索引进行重新排列，当新索引的值不存在时会以NaN输出
frame1 = frame.reindex(['a', 'b', 'c', 'd', 'f'])  
# frame1
frame2 = pd.Series(['blue', 'puple', 'yellow'], index=[0,2,4])
# frame2
frame2.reindex(range(6), method='ffill')  # method在重新索引时用于一些需要插值处理的操作(method='ffill'向前填充值)
frame.reindex(['a', 'b', 'c', 'd', 'e'], fill_value = 0)  #如果不想以NaN填充,可以用fill_value方法来设置

1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

• 再来看看DataFrame的reindex方法

import pandas as pd
import numpy as np
from pandas import Series, DataFrame
frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
   ....:                      index=['a', 'c', 'd'],
   ....:                      columns=['Ohio', 'Texas', 'California'])
 # reindex能修改DataFrame的行索引和列索引
frame2 = frame.reindex(['a', 'b', 'c', 'd']) # 若传递一个序列则会重新索引结果
frame2
states = ['Texas', 'Utah', 'California']
frame.reindex(columns=states)  # 列用关键字columns来重新索引
frame.reindex(columns=states).ffill()  # 对DataFrame使用ffill方法,对于新索引的列值还是输出NaN
# 在输出中出现‘标签索引loc方法(书中的'ix'方法已经不能使用了，loc方法等同原ix方法’解释
frame.loc[['a', 'b', 'c', 'd'], states]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 丢弃指定轴上的项

丢弃某条轴上的一个或多个项只要有一个索引数组或列表即可。采用drop方法返回在指定行轴或列轴删除指定值的新对象。

• 在Series中方法drop只能对一维组进行对行索引的删除

frame = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
# frame
frame_drop = frame.drop('c')  # drop('x')方法返回一个在指定行轴上删除指定值x的新对象
# frame_drop
# inplace保证修改Series和DataFrame的大小或形状时会在在正确的地方修改对象，从而输出新对象
frame.drop('c', inplace=True)  
# frame
1
2
3
4
5
6
7

• 在DataFrame中方法drop可以删除任意轴上的索引值

• >可以 通过传递axis=数字或axis='columns’来删除列的值

 data = pd.DataFrame(np.arange(16).reshape((4, 4)),
   .....:                     index=['Ohio', 'Colorado', 'Utah', 'New York'],
   .....:                     columns=['one', 'two', 'three', 'four'])
 data
 # 对列轴进行指定删除
 data.drop(['Utah', 'one'])  # 以标签的形式对列表中的行名删除对应值
 data.drop('four', axis=1)  # 通过传递axis=1来说明删除具体某一项对象列值
 data.drop(['two', 'four'], axis='columns')  # 通过传递axis=columns来说明是要删除列值
 # 对行轴进行指定删除
 data.drop('Ohio', axis='index')
 data.drop(['Utah', 'New York'])  # 以标签的形式对列表中的列名删除对应值
1
2
3
4
5
6
7
8
9
10
11

np.arange()和 range()的用法及区别：
1.a = np.arange()

1.一个参数是默认起点0，步长为1
a = np.arange(5) #输出：[0 1 2 3 4 5]
2.两个参数是默认步长为1
a = np.arange(3,6) #输出[3 4 5]
3.三个参数则是起点为0，终点为3，步长为0.5
a = np.arange(0, 3, 0.5) # 输出[ 0. 0.5 1. 1.5 2. 2.5]

2.range(start, stop[, step])

start为开始，stop为结束和step为步长

3.arange()是Numpy中的函数，range()则是python自带函数，它们主要区别是arange支持步长为小数而arange不支持、range返回的是object而arange返回的是ndarray类型，都可以用于迭代

3. 索引、选取、过滤操作

• 对于Series的单个索引和切片处理

frame = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
#frame
# frame[...]类似Numpy数组的索引(区别在于Series的索引值不只是整数)
frame['b']  
frame[3]
frame[2:4] # 对Series进行切片处理(与普通切片不同的地方在其末端在所切片中并输出)
frame[frame < 3]
frame['a':'c']
frame['a', 'c'] = 5  # 对于切片的相对应部分进行设置
#frame

1
2
3
4
5
6
7
8
9
10
11

• DataFrame进行索引就是获取对象的一个列或多个列

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                   index=['age', 'year', 'Utah', 'New York'],
                   columns=['one', 'two', 'three', 'four'])
data['one']  # 用单个值来获取
data[['one', 'three', 'four']]  # 用序列来获取
data[:2]  # 获取前两行
data[2:]  # 获取后两行
data[data['four'] > 5]  # 返回满足条件的新对象
data < 5  # 通过对标量的比较运算来索引(输出的h是bool值)
data[data < 5] = 22  # 对于小于比较运算的值都改为22
# data
1
2
3
4
5
6
7
8
9
10
11

4. loc和iloc的使用

• loc[行索引, 列索引]的用法

# 对DataFrame进行标签索引
data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                   index=['age', 'year', 'Utah', 'New York'],
                   columns=['one', 'two', 'three', 'four'])
data.loc['age', ['two', 'three']]  # 选取标签为单行多列
data.loc[:'Utah','two']  # loc进行一个标签或多个标签切片
1
2
3
4
5
6

• iloc[行序, 列序]

data.iloc[2, [3, 0, 1]]  # 对于行为2，列序[3, 0, 1]进行索引
data.iloc[3]  # 单独对行3进行索引
data.iloc[:, :3][data.three>5]  # iloc对于单个或多个标签的索引
1
2
3

5. 整数索引

pandas处理整数和python内置函数索引不同。
若pandas中index与columns整数值一样时，索引frame[x]会产生歧义而发生错误
从而引入非整数索引来消除歧义
索引数据最好是要使用loch和iloc

6. 算数运算和数据对齐

andas可以对不同的索引的对象进行算术运算。

1. 若frame1+frame2中存在不同索引对，则返回的结果是两个对象的索引并集。
2. 数据对齐时产生对于数据不重叠的索引都是返回缺失值NaN。
3. 对象相加时若没有相同的行或列标签，则都返回NaN值(DataFrame对齐操作可以同时对行和列操作)

7. 在算术方法中填充值

在对象进行算术运算时出现索引不重叠返回的都是NAN值，若不想要以NaN值输出而引入fill_value参数(frame.方法(frame1, fill_value=xx))

8. 排序sort和排名rank

sort是对行或列索引进行排序(升序、降序或自定义顺序)
rank是对行或列索引进行排名(从高到低、从低到高或自定义顺序排名)一般产生新的名次序列。

1. 排序
1

• sort_index()：按索引排序

sort_index(axis=1,ascending=False)
axis：行索引或列索引，默认为列索引排序，axis = 1或axis='index' 表示对行进行排序;
ascending：排序方式，默认升序，ascending=False 表降序,ascending=True表示升序。
1
2
3

obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
obj.sort_index()  # 对索引index进行排序
 frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
   .....:                      index=['three', 'one'],
   .....:                      columns=['d', 'a', 'b', 'c'])
frame.sort_index()
frame.sort_index(axis='columns')  # 对于列进行排序
# 数据默认是按升序排序的
frame.sort_index(axis=1, ascending=True)  # 对于ascending=False是降序排序
1
2
3
4
5
6
7
8
9

• sort_values()：按数值排序

    sort_values(ascending=False, by=‘b’)
    by：排序的依据，by=‘b’ 表示根据b列的数据进行排序；
    ascending：排序方式(True为升序、False为降序)。
1
2
3

obj = pd.Series([4, 7, -3, 2])
obj.sort_values()  # 按值进行排序
obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj.sort_values() # 任何缺失值都会默认放到Series一维数组的末尾
frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame.sort_values(by='b')  # 根据某个值来排序，用到by='xx'
frame.sort_values(by=['a', 'b'])  # 根据多个列进行排序，用到by=['xx', 'xxx']
1
2
3
4
5
6
7

2. 排名rank()：对数据进行排名
1

df.rank(ascending=False, method=‘max’)
ascending：排名方式(True为升序、False为降序);
method：排名方式，包括：“average”、“min”、“max”、“first”、“dense”。(默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系)

obj = pd.Series([7,-5,7,4,2,0,4])
obj.rank()  # 输出排名序号
# 也可以根据值在原数据中出现的顺序给出排名：
obj.rank(method='first')
obj.rank(ascending=False, method='max')  # 降序进行排名
frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
                      'c': [-2, 5, 8, -2.5]})
frame.rank(axis='columns')  #DataFrame可以在行或列上计算排名
1
2
3
4
5
6
7
8

9. 重复标签的轴索引

对于带有重复值的索引，数据选取的行为将会有所不同。如果索引对应多个值则输出一个Series(DataFrame)，索引单个值则输出一个标量。

汇总和计算描述统计

# 创建一个简单的DataFrame
df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                 [np.nan, np.nan], [0.75, -1.3]],
                 index=['a', 'b', 'c', 'd'],
                 columns=['one', 'two'])

1
2
3
4
5
6

• 相关系数和协方差

• 唯一值、值相关计算和成员资格

1.unique()得到Series中的唯一值数组

obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
uniques = obj.unique()  # 对结果再次进行排序（uniques.sort()）
# uniques
# 输出为
array(['c', 'a', 'd', 'b'], dtype=object)
1
2
3
4
5

2.value_counts用于计算一个Series中各值出现的频率

obj.value_counts()  # Series是按值频率降序排列的
# 输出为
c    3
a    3
b    2
d    1
dtype: int64
1
2
3
4
5
6
7

3.value_counts可用于任何数组或序列

pd.value_counts(obj.values, sort=False)
# 输出为
a    3
b    2
c    3
d    1
dtype: int64
1
2
3
4
5
6
7

4.isin用于判断矢量化集合的成员资格，可用于过滤Series或DataFrame列中数据的子集

mask = obj.isin(['b', 'c'])
# mask
# 输出为
0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool
obj[mask]  # 返回指定索引的数据
0    c
5    b
6    b
7    c
8    c
dtype: object
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5.Index.get_indexer方法是给你一个索引数组，从可能包含重复值的数组到另一个不同值的数组

to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a'])

unique_vals = pd.Series(['c', 'b', 'a'])

 pd.Index(unique_vals).get_indexer(to_match)  # 从to_math映射到unique_vals返回对应位置
 # 输出为
array([0, 2, 1, 1, 0, 2])
1
2
3
4
5
6
7