[Python知识库]Python-玩转数据-Pandas练习

1、了解你的数据

模拟测试数据
导入数据处理库pandas

import pandas as pd

利用pandas库读取csv文件赋值给容器chipo

chipo = pd.read_csv("工作簿1.csv",encoding='gbk')

读取文件前3行数据,并打印出数据

print(chipo.head(3))

查看数据集中有多少个列并打印

print(chipo.shape[1])

查看数据集中有多少行并打印

print(chipo.shape[0])

x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
#输出数组的行和列数
print x.shape  #结果： (4, 3)
#只输出行数
print x.shape[0] #结果： 4
#只输出列数
print x.shape[1] #结果： 3

print(chipo.columns)

查看数据集的索引是怎样的

print(chipo.index)

以门店分组汇总，汇总订单，并按订单进行降序排列,

c = chipo[['门店','订单']].groupby(['门店'],as_index=False).agg({'订单':sum})
c.sort_values(['订单'],ascending=False,inplace=True)
print(c.head())

as_index = True 是默认，as_index=False 是sql的输出风格，前面带有序号
ascending=False 表示排序为降序，默认为True 为排序的升序

2、数据过滤与排序

只选取 订单号 这一列并打印

print(chipo.订单号)

查看共有多少笔订单

print(chipo.shape[0])

该数据集中一共有多少列(columns)

print(chipo.info())

将数据集中的列单独存为discipline

discipline = chipo[['门店','订单','单价','订单号','地区']]
print(discipline)

对discipline框内数据按单价排序

print(discipline.sort_values(['单价'],ascending=False))

计算门店单价订单平均值

print(discipline['单价'].mean())

#找到单价大于3的订单

print(discipline[discipline.单价>3])

取以4开头的订单

print(discipline[discipline.地区.str.startswith('成')])

提取前三列

print(discipline.iloc[:,0:3])

除了后三列全部显示

print(discipline.iloc[:,0:-3])

筛选地址只有成都的记录

print(discipline.loc[discipline.地区.isin(['成都'])])

3、数据分组

打印按照门店分组的平均价

print(chipo.groupby('门店').单价.mean())

describe分析

print(chipo.groupby('门店').订单.describe())

对于一维数组，describe()返回值的解释如下：
count： 返回数组的个数
mean： 返回数组的平均值
std： 返回数组的标准差；
min： 返回数组的最小值；
25%，50%，75%： 返回数组的三个不同百分位置的数值，也就是统计学中的四分位数，其中50%对应的是中位数。
max： 返回列表的最大值。

打印出每个门店订单的中位数，相当与上面四分位中的50%

print(chipo.groupby('门店').订单.median())

打印门店订单的平均值，最小值，最大值

print(chipo.groupby('门店').订单.agg(['mean','min','max']))

4、数据合并

数据准备

raw_data_1 = {
        'subject_id': ['1', '2', '3', '4', '5'],
        'first_name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
        'last_name': ['Anderson', 'Ackerman', 'Ali', 'Aoni', 'Atiches']}

raw_data_2 = {
        'subject_id': ['4', '5', '6', '7', '8'],
        'first_name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
        'last_name': ['Bonder', 'Black', 'Balwner', 'Brice', 'Btisan']}

raw_data_3 = {
        'subject_id': ['1', '2', '3', '4', '5', '7', '8', '9', '10', '11'],
        'test_id': [51, 15, 15, 61, 16, 14, 15, 1, 61, 16]}

data1 = pd.DataFrame(raw_data_1, columns = ['subject_id', 'first_name', 'last_name'])
data2 = pd.DataFrame(raw_data_2, columns = ['subject_id', 'first_name', 'last_name'])
data3 = pd.DataFrame(raw_data_3, columns = ['subject_id','test_id'])

将data1,data2按行进行合并

print(pd.concat([data1,data2]))

将data1,data2按列进行合并

all_data = pd.concat([data1, data2])
print(pd.concat([data1,data2],axis = 1))

按照subject_id的值关联合并

print(pd.merge(all_data,data3,on='subject_id'))

内连接合并

print(pd.merge(data1,data2,on='subject_id',how='inner'))

外连接合并

print(pd.merge(data1,data2,on='subject_id',how='outer'))

5、从列表创建 Series

Series 类似表格中的一个列（column），类似于一维数组，可以保存任何数据类型。

arr = [0,1,2,3,4]
df = pd.Series(arr)
print(df)

6、从字典创建Series

d = {'a':1,'b':2,'c':3,'d':4,'e':5}
df = pd.Series(d)
print(df)

6、从 NumPy 数组创建 DataFrame

import numpy as np
import pandas as pd

dates = pd.date_range('today',periods=6) # 定义时间序列作为 index
print(dates)
num_arr = np.random.randn(6,4) # 传入 numpy 随机数组
print(num_arr)
columns = ['A','B','C','D'] # 将列表作为列名
print(columns)
df = pd.DataFrame(num_arr, index = dates, columns = columns)
print(df)

7、从CSV中创建 DataFrame

df = pd.read_csv('test.csv', encoding='gbk', sep=';')

8、从字典对象创建DataFrame，并设置索引

import pandas as pd
import numpy as np

data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
        'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],
        'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
        'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}

labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
df = pd.DataFrame(data, index=labels)
print(df)

9、取出上述df 的animal, age列

loc1 = df.loc[:, ['animal', 'age']]
print(loc1)

10、取出索引行的列

loc2 = df.loc[df.index[[3, 4, 8]], ['animal', 'age']] print(loc2)

11、取出值缺失的行

loc3 = df[df['age'].isnull()]
print(loc3)

12、修改某行某值

df.loc['f', 'age'] = 1.5
print(df.loc['f','age'])

13、替换某列某些值

df['animal'] = df['animal'].replace('snake', 'python')
print(df)

14、插入删除行

#插入
df.loc['k'] = [5.5, 'dog', 'no', 2]
# 删除
df = df.drop('k')
print(df)

15、删除数值重复的行

df = pd.DataFrame({'A': [1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7]})
print(df)
df1 = df.loc[df['A'].shift() != df['A']]
# 方法二
# df1 = df.drop_duplicates(subset='A')
print(df1)

16、 每个数字减去该行的平均数

df = pd.DataFrame(np.random.random(size=(5, 3)))
print(df)
df1 = df.sub(df.mean(axis=1), axis=0)
print(df1)

17、求哪一列的和最小

df = pd.DataFrame(np.random.random(size=(5, 5)), columns=list('abcde'))
print(df)
df2 = df.sum().idxmin()
print(df2)

18、求A列每个值的前3大的B的值的和

df = pd.DataFrame({'A': list('aaabbcaabcccbbc'),
                   'B': [12,345,3,1,45,14,4,52,54,23,235,21,57,3,87]})
print(df)
df1 = df.groupby('A')['B'].nlargest(3).sum()
print(df1)

19、分段求和

给定DataFrame，有列A, B，A的值在1-100（含），对A列每10步长，求对应的B的和

df = pd.DataFrame({'A': [1,2,11,11,33,34,35,40,79,99],
                   'B': [1,2,11,11,33,34,35,40,79,99]})
print(df)
df1 = df.groupby(pd.cut(df['A'],np.arange(0, 101, 10)))['B'].sum()
print(df1)

20、计算每个元素至左边最近的0（或者至开头）的距离，生成新列y

df = pd.DataFrame({'X': [7, 2, 0, 3, 4, 2, 5, 0, 3, 4]})

izero = np.r_[-1, (df['X'] == 0).to_numpy().nonzero()[0]] # 标记0的位置
idx = np.arange(len(df))
df['Y'] = idx - izero[np.searchsorted(izero - 1, idx) - 1]
print(df)

21、一个全数值的DataFrame，返回最大3个值的坐标

df = pd.DataFrame(np.random.random(size=(5, 3)))
print(df)
df.unstack().sort_values()[-3:].index.tolist()

22、 给定DataFrame，将负值代替为同组的平均值

df = pd.DataFrame({'grps': list('aaabbcaabcccbbc'), 
                   'vals': [-12,345,3,1,45,14,4,-52,54,23,-235,21,57,3,87]})
print(df)

def replace(group):
    mask = group<0
    group[mask] = group[~mask].mean()
    return group

df['vals'] = df.groupby(['grps'])['vals'].transform(replace)
print(df)

23、 计算3位滑动窗口的平均值，忽略NAN

df = pd.DataFrame({'group': list('aabbabbbabab'),
                    'value': [1, 2, 3, np.nan, 2, 3, np.nan, 1, 7, 3, np.nan, 8]})
print(df)

g1 = df.groupby(['group'])['value']
g2 = df.fillna(0).groupby(['group'])['value'] 

s = g2.rolling(3, min_periods=1).sum() / g1.rolling(3, min_periods=1).count()
s.reset_index(level=0, drop=True).sort_index()

24、 创建Series s，将2015所有工作日作为随机值的索引

dti = pd.date_range(start='2015-01-01', end='2015-12-31', freq='B') 
s = pd.Series(np.random.rand(len(dti)), index=dti)

s.head(10)

25、 所有礼拜三的值求和

s[s.index.weekday == 2].sum()

26、. 求每个自然月的平均数

s.resample('M').mean()

27、每连续4个月为一组，求最大值所在的日期

s.groupby(pd.Grouper(freq='4M')).idxmax()

28、 创建2015-2016每月第三个星期四的序列

pd.date_range('2015-01-01', '2016-12-31', freq='WOM-3THU')

数据清洗
df = pd.DataFrame({'From_To': ['LoNDon_paris', 'MAdrid_miLAN', 'londON_StockhOlm', 
                               'Budapest_PaRis', 'Brussels_londOn'],
              'FlightNumber': [10045, np.nan, 10065, np.nan, 10085],
              'RecentDelays': [[23, 47], [], [24, 43, 87], [13], [67, 32]],
                   'Airline': ['KLM(!)', '<Air France> (12)', '(British Airways. )', 
                               '12. Air France', '"Swiss Air"']})
df

29、 FlightNumber列中有些值缺失了，他们本来应该是每一行增加10，填充缺失的数值，并且令数据类型为整数

df['FlightNumber'] = df['FlightNumber'].interpolate().astype(int)
df

30、 将From_To列从_分开，分成From, To两列，并删除原始列

temp = df.From_To.str.split('_', expand=True)
temp.columns = ['From', 'To']
df = df.join(temp)
df = df.drop('From_To', axis=1)
df

31、 将From, To大小写统一首字母大写其余小写

df['From'] = df['From'].str.capitalize()
df['To'] = df['To'].str.capitalize()
df

32、 Airline列，有一些多余的标点符号，需要提取出正确的航司名称。举例：’(British Airways. )’ 应该改为 ‘British Airways’.

df['Airline'] = df['Airline'].str.extract('([a-zA-Z\s]+)', expand=False).str.strip()
df

33、 Airline列，数据被以列表的形式录入，但是我们希望每个数字被录入成单独一列，delay_1, delay_2, …没有的用NAN替代。

delays = df['RecentDelays'].apply(pd.Series)
delays.columns = ['delay_{}'.format(n) for n in range(1, len(delays.columns)+1)]
df = df.drop('RecentDelays', axis=1).join(delays)
df

34、 用 letters = [‘A’, ‘B’, ‘C’]和 numbers = list(range(10))的组合作为系列随机值的层次化索引

letters = ['A', 'B', 'C']
numbers = list(range(4))

mi = pd.MultiIndex.from_product([letters, numbers])
s = pd.Series(np.random.rand(12), index=mi)
s

35、 检查s是否是字典顺序排序的

s.index.is_lexsorted()

# 方法二
# s.index.lexsort_depth == s.index.nlevels

36、对s进行切片操作，取一级索引至B，二级索引从2开始到最后

s.loc[pd.IndexSlice[:'B', 2:]]


# 方法二
# s.loc[slice(None, 'B'), slice(2, None)]

37、计算每个一级索引的和（A, B, C每一个的和）

s.sum(level=0)
#方法二
#s.unstack().sum(axis=0)

38、 交换索引等级，新的Series是字典顺序吗？不是的话请排序

new_s = s.swaplevel(0, 1)
print(new_s)
print(new_s.index.is_lexsorted())
new_s = new_s.sort_index()
print(new_s)
可视化
import matplotlib.pyplot as plt
df = pd.DataFrame({"xs":[1,5,2,8,1], "ys":[4,2,1,9,6]})
plt.style.use('ggplot')
48. 画出df的散点图

df.plot.scatter("xs", "ys", color = "black", marker = "x")

39. 可视化指定4维DataFrame

df = pd.DataFrame({"productivity":[5,2,3,1,4,5,6,7,8,3,4,8,9],
                   "hours_in"    :[1,9,6,5,3,9,2,9,1,7,4,2,2],
                   "happiness"   :[2,1,3,2,3,1,2,3,1,2,2,1,3],
                   "caffienated" :[0,0,1,1,0,0,0,0,1,1,0,1,0]})

df.plot.scatter("hours_in", "productivity", s = df.happiness * 100, c = df.caffienated)

40、 在同一个图中可视化2组数据，共用X轴，但y轴不同

df = pd.DataFrame({"revenue":[57,68,63,71,72,90,80,62,59,51,47,52],
                   "advertising":[2.1,1.9,2.7,3.0,3.6,3.2,2.7,2.4,1.8,1.6,1.3,1.9],
                   "month":range(12)})

ax = df.plot.bar("month", "revenue", color = "green")
df.plot.line("month", "advertising", secondary_y = True, ax = ax)
ax.set_xlim((-1,12));

参考网址：
https://www.runoob.com/pandas/pandas-tutorial.html