python之pandas模块

首先导入所需模块pandas

import pandas as pd
import numpy as np
import  string

Series数据类型

1.pandas创建Series数据类型
1).通过列表创建Series对象
不指定索引:

array = ["粉条", "粉丝", "粉带"]
s1 = pd.Series(data=array)  # 如果不指定索引,默认从0开始
print(s1)
# 0    粉条
# 1    粉丝
# 2    粉带
# dtype: object

指定索引:

array = ["粉条", "粉丝", "粉带"]
s1 = pd.Series(data=array,index=['A','B','C'])  # 指定索引
print(s1)
# A    粉条
# B    粉丝
# C    粉带
# dtype: object

2).通过numpy的对象Ndarray创建Series

n = np.random.randn(5)
s2 = pd.Series(data=n)
print(s2)
#
0    1.603141
1    1.451584
2    1.011957
3    1.234106
4   -0.728547
dtype: float64

3).通过字典创建Series对象

dict = {string.ascii_lowercase[i]:i for i in range(10)}
s3 = pd.Series(dict)
print(s3)
#
a    0
b    1
c    2
d    3
e    4
f    5
g    6
h    7
i    8
j    9
dtype: int64

2.Series的基本操作
1).修改Series索引

array = ["粉条", "粉丝", "粉带"]
s1 = pd.Series(data=array)
print(s1)
# 
0    粉条
1    粉丝
2    粉带
dtype: object

print(s1.index)
# RangeIndex(start=0, stop=3, step=1)

s1.index = ['A', 'B', 'C'] # 修改索引为A,B,C
print(s1)
# 
A    粉条
B    粉丝
C    粉带
dtype: object

2). Series纵向拼接

array = ["粉条", "粉丝", "粉带"]
s1 = pd.Series(data=array)
array1 = ["粉条", "粉丝", "粉带"]
s2 = pd.Series(data=array1)
s3 = s1.append(s2)
print(s3)
#
A    粉条
B    粉丝
C    粉带
0    粉条
1    粉丝
2    粉带
dtype: object

3). 删除指定索引对应的元素

array = ["粉条", "粉丝", "粉带"]
s1 = pd.Series(data=array,index=['A','B','C'])  # 指定索引
print(s1)
s4 = s1.drop('C')  # 删除索引为‘C’对应的值;
print(s4)
#
A    粉条
B    粉丝
dtype: object

4). 根据指定的索引查找元素

array = ["粉条", "粉丝", "粉带"]
s3 = pd.Series(data=array,index=['A','B','C'])  # 指定索引
print(s3['B'])
# 粉丝

s3['B'] = np.nan
print(s3)
# 
A     粉条
B    NaN
C    粉带
dtype: object

5). 切片操作

array = ["粉条", "粉丝", "粉带"]
s3 = pd.Series(data=array,index=['A','B','C'])  # 指定索引

print(s3[:2]) # 显示前两个元素
# 
A    粉条
B    粉丝
dtype: object

print(s3[::-1]) # 反转
#
C    粉带
B    粉丝
A    粉条
dtype: object

print(s3[-2:])  # 显示最后两个元素
#
B    粉丝
C    粉带
dtype: object

3.Series运算

import pandas as pd
import numpy as np
import  string

s1  = pd.Series(np.arange(5), index=list(string.ascii_lowercase[:5]))
s2  = pd.Series(np.arange(2, 8), index=list(string.ascii_lowercase[2:8]))

print(s1)
# 
a    0
b    1
c    2
d    3
e    4
dtype: int64

print(s2)
# 
c    2
d    3
e    4
f    5
g    6
h    7
dtype: int64

1).加法
相同索引的数值相加,没有相同索引的值为缺失值

print(s1 + s2)
# print(s1.add(s2)) # 等同于‘+’
# 
a    NaN
b    NaN
c    4.0
d    6.0
e    8.0
f    NaN
g    NaN
h    NaN
dtype: float64

2).减法

print(s1 - s2)
# 等同于 print(s1.sub(s2))
# 
a    NaN
b    NaN
c    0.0
d    0.0
e    0.0
f    NaN
g    NaN
h    NaN
dtype: float64

3).乘法

print(s1 * s2)
# print(s1.mul(s2))
# 
a     NaN
b     NaN
c     4.0
d     9.0
e    16.0
f     NaN
g     NaN
h     NaN
dtype: float64

4).除法

print(s1 / s2)
# print(s1.div(s2))
#
a    NaN
b    NaN
c    1.0
d    1.0
e    1.0
f    NaN
g    NaN
h    NaN
dtype: float64

5).求中位数

print(s1.median())
# 2.0

6).求和

print(s1.sum())
# 10

7).最大值

print(s1.max())
# 4

8).最小值

print(s1.min())
# 0

9).特殊的where方法
Series中的where方法运行结果和numpy中完全不同

s1 = pd.Series(np.arange(5), index=list(string.ascii_lowercase[:5]))
print(s1)
# 
a    0
b    1
c    2
d    3
e    4
dtype: int64

# 对象中不大于3的元素赋值为缺失值
print(s1.where(s1 > 3))
# 
a    NaN
b    NaN
c    NaN
d    NaN
e    4.0
dtype: float64

# 对象中不大于3的元素赋值为10;
print(s1.where(s1 > 3, 10))
# 
a    10
b    10
c    10
d    10
e     4
dtype: int64

# 对象中大于3的元素赋值为10;
print(s1.mask(s1 > 3, 10))
#
a     0
b     1
c     2
d     3
e    10
dtype: int64

DataFrame数据类型

1.pandas创建DataFrame数据类型
1).通过列表创建

li = [
    [1, 2, 3, 4],
    [2, 3, 4, 5]
]

# DataFRame对象里面包含两个索引, 行索引(0轴, axis=0), 列索引(1轴, axis=1)
d1 = pd.DataFrame(data=li, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d1)
# 
   views  loves  comments  tranfers
A      1      2         3         4
B      2      3         4         5

2).通过numpy对象创建

narr = np.arange(8).reshape(2, 4)
# DataFRame对象里面包含两个索引, 行索引(0轴, axis=0), 列索引(1轴, axis=1)
d2 = pd.DataFrame(data=narr, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d2)
# 
   views  loves  comments  tranfers
A      0      1         2         3
B      4      5         6         7

3).通过字典的方式创建

dict = {
    'views': [1, 2 ],
    'loves': [2, 3 ],
    'comments': [3, 4 ]
}
d3 = pd.DataFrame(data=dict, index=['粉条', "粉丝"])
print(d3)
#
    views  loves  comments
粉条      1      2         3
粉丝      2      3         4

有关日期的操作pd.date_range()

dates = pd.date_range(start='1/1/2018', end='1/08/2018')
print(dates)
# 默认按天数来分隔
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
               '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
              dtype='datetime64[ns]', freq='D')

例1:

# 行索引
dates = pd.date_range(start='today', periods=6)
# 数据
data_arr = np.random.randn(6, 4)
# 列索引
columns = ['A', 'B', 'C', 'D']
d4 = pd.DataFrame(data_arr, index=dates, columns=columns)
print(d4)
# 
                                   A         B         C         D
2019-02-27 14:57:47.555758  0.120459  0.020717 -0.231611 -0.467826
2019-02-28 14:57:47.555758 -0.533083  0.900358 -1.166000 -1.356933
2019-03-01 14:57:47.555758  0.429399  1.589066  0.062517 -1.709545
2019-03-02 14:57:47.555758 -2.182392  1.434439  0.106964  0.872465
2019-03-03 14:57:47.555758  0.111128 -1.365457  0.185828 -0.731432
2019-03-04 14:57:47.555758 -1.450903 -0.054512  0.112919 -0.210644

例2:一维对象: 建立一个以2019年每一天作为索引, 值为随机数

dates = pd.date_range(start='1/1/2019', end='12/31/2019', freq='D')
datas = np.random.randn(len(dates))
s1 = pd.Series(datas, index=dates)
print(s1[:3])  # 这里之显示前三行
# 
2019-01-01    0.311031
2019-01-02    0.279827
2019-01-03    0.392495
Freq: D, dtype: float64

2.DataFramede基本操作

narr = np.arange(8).reshape(2, 4)
# DataFRame对象里面包含两个索引, 行索引(0轴, axis=0), 列索引(1轴, axis=1)
d2 = pd.DataFrame(data=narr, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d2)
# 
   views  loves  comments  tranfers
A      0      1         2         3
B      4      5         6         7

1).查看基础属性

print(d2.shape)  # 获取行数和列数
# (2, 4)
print(d2.dtypes)  # 列数据类型
# 
views       int64
loves       int64
comments    int64
tranfers    int64
dtype: object
print(d2.ndim)  # 获取数据的维度
# 2
print(d2.index) # 行索引
# Index(['A', 'B'], dtype='object')
print(d2.columns) # 列索引
# Index(['views', 'loves', 'comments', 'tranfers'], dtype='object')
print(d2.values, type(d2.values))   # 对象的值, 二维ndarray数组;
#
 [[0 1 2 3]
 [4 5 6 7]] <class 'numpy.ndarray'>

2). 数据整体状况的查询
显示头部或尾部的几行

print(d2.head(1))  # 显示头部的几行, 默认5行
# 
   views  loves  comments  tranfers
A      0      1         2         3

print(d2.tail(1))  # 显示头部的尾行, 默认5行
# 
   views  loves  comments  tranfers
B      4      5         6         7

相关信息的预览: 行数, 列数, 列类型, 内存占用

# 相关信息的预览: 行数, 列数, 列类型, 内存占用
print("info:", d2.info())
# 
<class 'pandas.core.frame.DataFrame'>
Index: 2 entries, A to B
Data columns (total 4 columns):
views       2 non-null int64
loves       2 non-null int64
comments    2 non-null int64
tranfers    2 non-null int64
dtypes: int64(4)
memory usage: 80.0+ bytes
info: None

快速综合用计结果: 计数, 均值, 标准差, 最小值, 1/4位数, 中位数, 3/4位数, 最大值

print(d2.describe())
# 
          views     loves  comments  tranfers
count  2.000000  2.000000  2.000000  2.000000
mean   2.000000  3.000000  4.000000  5.000000
std    2.828427  2.828427  2.828427  2.828427
min    0.000000  1.000000  2.000000  3.000000
25%    1.000000  2.000000  3.000000  4.000000
50%    2.000000  3.000000  4.000000  5.000000
75%    3.000000  4.000000  5.000000  6.000000
max    4.000000  5.000000  6.000000  7.000000

转置操作

print(d2.T)
# 
          A  B
views     0  4
loves     1  5
comments  2  6
tranfers  3  7

按列进行排序

print(d2)
# 
   views  loves  comments  tranfers
A      0      1         2         3
B      4      5         6         7

# 按照指定列进行排序, 默认是升序, 如果需要降序显示,设置ascending=False;
print(d2.sort_values(by="views", ascending=False))
# 
   views  loves  comments  tranfers
B      4      5         6         7
A      0      1         2         3

切片及查询

print(d2[:1])   # 可以实现切片, 但是不能索引;
# 
   views  loves  comments  tranfers
A      0      1         2         3

print('1:\n', d2['views'])   # 通过标签查询, 获取单列信息
# 1:
 A    0
B    4
Name: views, dtype: int64

print('2:\n', d2.views)   # 和上面是等价的;
# 2:
 A    0
B    4
Name: views, dtype: int64

print(d2[['views', 'comments']])  # 通过标签查询多列信息
# 
   views  comments
A      0         2
B      4         6

通过类似索引的方式查询
iloc(通过位置进行行数据的获取)

print(d2.iloc[0])
# 
views       0
loves       1
comments    2
tranfers    3
Name: A, dtype: int64

print(d2.iloc[-1:])
# 
   views  loves  comments  tranfers
B      4      5         6         7

loc(t通过标签索引行数据)

print(d2.loc['A'])
# 
views       0
loves       1
comments    2
tranfers    3
Name: A, dtype: int64

更改pandas的值

d2.loc['A'] = np.nan
print(d2)
# 
views  loves  comments  tranfers
A    NaN    NaN       NaN       NaN
B    4.0    5.0       6.0       7.0

从文件中读取,保存数据

import pandas as pd
df = pd.DataFrame(
    {'province': ['陕西', '陕西', '四川', '四川', '陕西'],
     'city': ['咸阳', '宝鸡', '成都', '成都', '宝鸡'],
     'count1': [1, 2, 3, 4, 5],
     'count2': [1, 2, 33, 4, 5]
     }
)

df.to_csv('doc/csvFile.csv')   # csv文件的写入

df2 = pd.read_csv('doc/csvFile.csv')  # csv文件的读取

df2.to_excel("/tmp/excelFile.xlsx", sheet_name="省份统计")  # excel文件的写入

分组与聚合操作之groupby

pandas提供了一个灵活高效的groupby功能,
1). 它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。
2). 根据一个或多个键(可以是函数、数组或DataFrame列>名)拆分pandas对象。
3). 计算分组摘要统计,如计数、平均值、标准差,或用户自定义函数。
例:

import pandas as pd
df = pd.DataFrame(
    {'province': ['陕西', '陕西', '四川', '四川', '陕西'],
     'city': ['咸阳', '宝鸡', '成都', '成都', '宝鸡'],
     'count1': [1, 2, 3, 4, 5],
     'count2': [1, 2, 33, 4, 5]
     }
)

1.根据省市统计进行统计分析

grouped = df['count1'].groupby(df['province'])
print(grouped.describe())
# 
          count      mean       std  min   25%  50%   75%  max
province                                                      
四川          2.0  3.500000  0.707107  3.0  3.25  3.5  3.75  4.0
陕西          3.0  2.666667  2.081666  1.0  1.50  2.0  3.50  5.0

2.根据城市统计分析cpunt1的信息

grouped = df['count1'].groupby(df['city'])
print(grouped.max())
# 
city
咸阳    1
宝鸡    5
成都    4
Name: count1, dtype: int64

3.指定多个key值进行分类聚合

grouped = df['count1'].groupby([df['province'], df['city']])

print(grouped.max())
# 
四川        成都      4
陕西        咸阳      1
           宝鸡      5
Name: count1, dtype: int64
           
print(grouped.sum())
# 
province  city
四川        成都      7
陕西        咸阳      1
          宝鸡      7
Name: count1, dtype: int64

print(grouped.count())
# 
province  city
四川        成都      2
陕西        咸阳      1
          宝鸡      2
Name: count1, dtype: int64

4.通过unstack方法, 实现层次化的索引

print(grouped.max().unstack())
# 
city       咸阳   宝鸡   成都
province               
四川        NaN  NaN  4.0
陕西        1.0  5.0  NaN
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值