pandas
安装: pip install pandas
应用: import pandas as pd
两个数据结构：
a. Series:
定义:Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签(索引)组成
创建方式:
第一种：
pd.Series([4,5,6,7,8])
执行结果：
0 4
1 5
2 6
3 7
4 8
dtype: int64
# 将数组索引以及数组的值打印出来，索引在左，值在右;
# 没有为数据指定索引，会自动创建一个0到N-1的整数型索引，取值的时候可以通过索引取值
-----------------------------------------------
第二种：
pd.Series([4,5,6,7,8],index=['a','b','c','d','e'])
执行结果：
a 4
b 5
c 6
d 7
e 8
dtype: int64
# 自定义索引，index是一个索引列表，里面包含的是字符串，依然可以通过默认索引取值。
-----------------------------------------------
第三种：
pd.Series({"a":1,"b":2})
执行结果：
a 1
b 2
dtype: int64
# 指定索引
-----------------------------------------------
第四种：
pd.Series(0,index=['a','b','c'])
执行结果：
a 0
b 0
c 0
dtype: int64
# 创建一个值都是0的数组
1.对缺失值的处理
1.dropna:删掉缺失值
2.filena:填充缺失数据
3.isnull:返回布尔数组,缺失值为true
4.notnull: 缺失值为flase
# 第一步，创建一个字典，通过Series方式创建一个Series对象
st = {"sean":18,"yang":19,"bella":20,"cloud":21}
obj = pd.Series(st)
obj
运行结果：
sean 18
yang 19
bella 20
cloud 21
dtype: int64
------------------------------------------
# 第二步
a = {'sean','yang','cloud','rocky'} # 定义一个索引变量
------------------------------------------
#第三步
obj1 = pd.Series(st,index=a)
obj1 # 将第二步定义的a变量作为索引传入
# 运行结果：
rocky NaN
cloud 21.0
sean 18.0
yang 19.0
dtype: float64
# 因为rocky没有出现在st的键中，所以返回的是缺失值
通过上面的代码演示，对于缺失值已经有了一个简单的了解，接下来就来看看如何判断缺失值
Copy
1、
obj1.isnull() # 是缺失值返回Ture
运行结果：
rocky True
cloud False
sean False
yang False
dtype: bool
2、
obj1.notnull() # 不是缺失值返回Ture
运行结果：
rocky False
cloud True
sean True
yang True
dtype: bool
3、过滤缺失值 # 布尔型索引
obj1[obj1.notnull()]
运行结果：
cloud 21.0
yang 19.0
sean 18.0
dtype: float64
2.series特性:
与标量（数字）进行运算：sr * 2
srx = sr * 2 # 与标量（数字）进行运算
两个Series运算
sr * srx # 两个Series运算
布尔值过滤：sr[sr>0]
sr[sr>3] # 布尔索引
2.1支持字典的特性:
# 字典创建Series
dic_arr = pd.Series({"A":1,"B":2,"C":3,"D":4,"E":5}
)
In运算：'a'in sr、for x in sr
"A" in dic_arr
------------------------------
for i in dic_arr:
print(i)
键索引：sr['a'],sr[['a','b','d']]
dic_arr[['A','B']] # 键索引
键切片：sr['a':'c']
dic_arr['A':'C'] # 键切片
其他函数：get('a',default=0)等
dic_arr.get("A",default=0)
loc属性 # 以标签解释
iloc属性 # 以下标解释
b. DataFrame:
1.定义:是一个表格型的数据结构，相当于是一个二维数组，含有一组有序的列。
他可以被看做是由Series组成的字典，并且共用一个索引。
2.创建:
第一种：
pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
# 产生的DataFrame会自动为Series分配所索引，并且列会按照排序的顺序排列
运行结果：
one two
0 1 4
1 2 3
2 3 2
3 4 1
> 指定列
可以通过columns参数指定顺序排列
data = pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
pd.DataFrame(data,columns=['one','two'])
第二种：
pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3],index=['b','a','c'])})
运行结果：
one two
a 1 2
b 2 1
c 3 3
3.常用属性和方法:
1.index 获取行索引
2.columns 获取列索引
3.T 转置
4.values 获取值索引
5.describe 获取快速统计
one two
a 1 2
b 2 1
c 3 3
-----------------------------------------------------------------------------
df.index
运行结果：
Index(['a', 'b', 'c'], dtype='object')
----------------------------------------------------------------------------
df.columns
运行结果：
Index(['one', 'two'], dtype='object')
--------------------------------------------------------------------------
df.T
运行结果：
a b c
one 1 2 3
two 2 1 3
-------------------------------------------------------------------------
df.values
运行结果：
array([[1, 2],
[2, 1],
[3, 3]], dtype=int64)
------------------------------------------------------------------------
df.describe()
运行结果：
one two
count 3.0 3.0 #数据统计
mean 2.0 2.0 #平均值
std 1.0 1.0 #标准差
min 1.0 1.0
25% 1.5 1.5 #四分之一均值
50% 2.0 2.0
75% 2.5 2.5
max 3.0 3.0
4.索引切片
loc属性： 解释为标签
iloc属性：解释为下标
data.loc[:10,"open":"low"] # 用标签取值
data.iloc[:10,1:5] # 用下标取值
注:
DataFrame有行索引和列索引。
DataFrame同样可以通过标签和位置两种方法进行索引和切片
5.时间处理对象
import dateutil
dateutil.parser.parse("2019 Jan 2nd") # 这中间的时间格式一定要是英文格式
>datetime.datetime(2019, 1, 2, 0, 0)
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
运行结果：
DatetimeIndex(['2018-03-01', '2019-02-03', '2019-08-12'], dtype='datetime64[ns]', freq=None) # 产生一个DatetimeIndex对象
# 转换时间索引
ind = pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
sr = pd.Series([1,2,3],index=ind)
sr
运行结果：
2018-03-01 1
2019-02-03 2
2019-08-12 3
dtype: int64
通过以上方式就可以将索引转换为时间
补充：
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019']).to_pydatetime()
运行结果：
array([datetime.datetime(2018, 3, 1, 0, 0),
datetime.datetime(2019, 2, 3, 0, 0),
datetime.datetime(2019, 8, 12, 0, 0)], dtype=object)
# 通过to_pydatetime()方法将其转换为array数组
产生时间对象数组：data_range
start 开始时间
end 结束时间
periods 时间长度
freq 时间频率，默认为'D'，可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…
pd.date_range("2019-1-1","2019-2-2")
运行结果：
DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
'2019-01-05', '2019-01-06', '2019-01-07', '2019-01-08',
'2019-01-09', '2019-01-10', '2019-01-11', '2019-01-12',
'2019-01-13', '2019-01-14', '2019-01-15', '2019-01-16',
'2019-01-17', '2019-01-18', '2019-01-19', '2019-01-20',
'2019-01-21', '2019-01-22', '2019-01-23', '2019-01-24',
'2019-01-25', '2019-01-26', '2019-01-27', '2019-01-28',
'2019-01-29', '2019-01-30', '2019-01-31', '2019-02-01',
'2019-02-02'],
dtype='datetime64[ns]', freq='D')
时间序列
时间序列就是以时间对象为索引的Series或DataFrame。datetime对象作为索引时是存储在DatetimeIndex对象中的。
# 转换时间索引
dt = pd.date_range("2019-01-01","2019-02-02")
a = pd.DataFrame({"num":pd.Series(random.randint(-100,100) for _ in range(30)),"date":dt})
# 先生成一个带有时间数据的DataFrame数组
a.index = pd.to_datetime(a["date"])
# 再通过index修改索引
特殊功能：
传入“年”或“年月”作为切片方式
传入日期范围作为切片方式
丰富的函数支持：resample(), strftime(), ……
批量转换为datetime对象：to_pydatetime()
a.resample("3D").mean() # 计算每三天的均值
a.resample("3D").sum() # 计算每三天的和
6.数据分组与聚合
apply: GroupBy当中自由度最高的方法,
用法:它会将待处理的对象拆分为多个片段，然后各个片段分别调用传入的函数，最后将它们组合到一起。
df.apply(
['func', 'axis=0', 'broadcast=None', 'raw=False', 'reduce=None', 'result_type=None', 'args=()', '**kwds']
)
func:传入一个自定义函数
axis:函数传入参数当axis=1就会把一行数据作为Series的数据
a.分组(GroupBY机制)
df = pd.DataFrame({'key1':['x','x','y','y','x',
'key2':['one','two','one',',two','one'],
'data1':np.random.randn(5),
'data2':np.random.randn(5)})
df
> key1 key2 data1 data2
0 x one 0.951762 1.632336
1 x two -0.369843 0.602261
2 y one 1.512005 1.331759
3 y two 1.383214 1.025692
4 x one -0.475737 -1.182826
访问data1，并根据key1调用groupby：
f1 = df['data1'].groupby(df['key1']).groups #属性
f1
> <pandas.core.groupby.groupby.SeriesGroupBy object at 0x00000275906596D8>
上述运行是没有进行任何计算的，接下来，就可以调用groupby进行任何计算
f1.mean() # 调用mean函数求出平均值
> key1
x 0.106183
y 2.895220
Name: data1, dtype: float64
以上数据经过分组键（一个Series数组）进行了聚合，产生了一个新的Series，索引就是key1列中的唯一值。这些索引的名称就为key1。接下来就尝试一次将多个数组的列表传进来
f2 = df['data1'].groupby([df['key1'],df['key2']])
f2.mean()
> key1 key2
x one 0.083878
two 0.872437
y one -0.665888
two -0.144310
Name: data1, dtype: float64
传入多个数据之后会发现，得到的数据具有一个层次化的索引，key1对应的x\y;key2对应的one\two.
f2.mean().unstack() # 通过unstack方法就可以让索引不堆叠在一起了
> key2 one two
key1
x 0.083878 0.872437
y -0.665888 -0.144310
补充：
1、分组键可以是任意长度的数组
2、分组时，对于不是数组数据的列会从结果中排除，例如key1、key2这样的列
3、GroupBy的size方法，返回一个含有分组大小的Series
# 以上面的f2测试
f2.size()
> key1 key2
x one 2
two 1
y one 1
two 1
Name: data1, dtype: int64
b.聚合
um 非NA值的和
median 非NA值的算术中位数
std、var 无偏（分母为n-1）标准差和方差
prod 非NA值的积
first、last 第一个和最后一个非NA值
常用方法:
mean(axis=0,skipna=False)
sum(axis=1)
sort_index(axis, …, ascending) # 按行或列索引排序
sort_values(by, axis, ascending) # 按值排序
apply(func, axis=0) # 将自定义函数应用在各行或者各列上，func可返回标量或者Series
applymap(func) # 将函数应用在DataFrame各个元素上
map(func) # 将函数应用在Series各个元素上
浙公网安备 33010602011771号