Pandas 快捷入门

Pandas 快捷入门

1、 Pandas创建序列

dates = pd.date_range('20200301',periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))
df

# 使用字典来创建：key 为 DataFrame 的列；value 为对应列下的值
df1 = pd.DataFrame({
                  'A': 1,
                  'B': pd.Timestamp('20200301'),
                  'C': range(4),
                  'D': np.arange(5, 9),
                  'E': 'text',
                  'F': ['AA', 'BB', 'CC', 'DD']})
df1

2.查看数据

• 查看数据形状
  df.shape

• 查看首行数据
  df.head()
df.head(3)

• 查看末尾数据
  df.tail()
df.tail(3)

• 查看序列号
  df.index

• 查看列名
  df.columns

• 查看描述性数据统计
  df.describe()

• 数据转置
  df.T

• 按行名进行倒序排列
  df.sort_index(axis=1, ascending=False)
  

• 按 'C’列的数值进行排序，默认为倒序排列
  df.sort_values(by='C')
  

3.选择数据

1).通过标签选择

df.loc['20200301']
df.loc[:, ['A', 'B']]
df.loc['20200301':'20200305', ['A', 'B']]

2).通过位置选择

df.iloc[1]
选择第2行的数据

df.iloc[2:5, 0:2]

3).布尔索引

df[df.A < 0]
只取 A 列中值大于 0 的行

4.处理丢失数据

Pandas 使用numpy.NaN 来表示丢失的数据，它不参与计算。
先创建一个含有丢失数据的 DataFrame

ates = pd.date_range('20200301', periods=6)
df = pd.DataFrame(data=np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
df1.loc[dates[1:3], 'E'] = 1
df1

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200327172655457.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N5Z25ldDQ3Nw==,size_16,color_FFFFFF,t_70

• 删除所有存在空值的行
  df.dropna(how='any') !
  
• 对空值进行填充
  df1.fillna(value=5)
  

5.统计运算

numpy.NaN 不参与计算

• 计算每列的平均值
  df1.mean()
• 计算每行的平均值
  df.mean(axis=1)
• 按列求和
  df.sum()
• 按行求和
  df.sum(axis='columns')
  -按行求累加
  df.cumsum()

6.数据合并

• 纵向进行拼接使用 concat

df = pd.DataFrame(np.random.randn(10, 4), columns=list('ABCD'))
df1=df.iloc[:3]
df2=df.iloc[3:7]
df3=df.iloc[7:10]
df4= pd.concat([df1,df2,df3])

• 横向进行联合查询使用 merge

left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
pd.merge(left, right, on='key')

上述语句等于 SQL 中的 INNER JOIN

SELECT * FROM left INNER JOIN right ON left.key = right.key;

7.分组统计

先创建一个数据表

df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
                          'foo', 'bar', 'foo', 'foo'],
                   'B' : ['one', 'one', 'two', 'three',
                           'two', 'two', 'one', 'three'],
                   'C' : np.random.randn(8),
                   'D' : np.random.randn(8)})

• 以 A 列为分组依据进行求和
  df.groupby('A').sum()

• 以 A\B 两列为分组依据进行求和
  df.groupby(['A', 'B']).sum()
  此处 A B 的顺序代表先以谁进行分组
  

8.数据整型

首先创建一个数据框

tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',
                     'foo', 'foo', 'qux', 'qux'],
                    ['one', 'two', 'one', 'two',
                     'one', 'two', 'one', 'two']]))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
df

stacked = df.stack()
stacked.unstack()

9.数据透视

创建一个可用于数据透视的表

df = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,
                    'B' : ['dog', 'cat', 'fish'] * 4,
                    'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
                    'D' : np.random.randn(12),
                    'E' : np.random.randn(12)})

• 以 AB 为序列，D 为值进行透视

pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])

10.时间序列

创建一个长度为 600，间隔为 1 秒，起始时间为 2020 年 1 月 3 日的时间序列

rng = pd.date_range('20200301', periods=600, freq='s')

根据上面的时间序列，随机创建一个数据框，其中数值为 0-500 的随机数，长度与上述时间序列一致

ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)

• 对上述数据框按照 2 分钟进行求和

ts.resample('2Min', how='sum')

11.数据读写

• 数据读取

pd.read_csv('data.csv')

• 数据存储

df.to_csv('data.csv')

12.Pandas全球电影数据分析

1).导入相关库和数据

#导入相关库
%matplotlib inline
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

#导入电影数据，由于原始数据没有列名，故要先创建数据框，所有数据都是以‘::’进行分割。
user_names = ['user_id','gender','age','occupation','zip']
users=pd.read_table('users.dat',sep='::',header=None,names=user_names,engine='python')

rating_names = ['user_id', 'movie_id', 'rating', 'timestamp']
ratings = pd.read_table('ratings.dat', sep='::', header=None, names=rating_names, engine='python')

movie_names = ['movie_id', 'title', 'genres']
movies = pd.read_table('movies.dat', sep='::', header=None, names=movie_names, engine='python')

查看数据：

users.head()

• users 用户信息表中包含了用户 id、性别、年龄、职业、邮编等信息；

movies.head()

• movies 电影信息表中包含了电影 id、电影名、电影类型等信息

ratings.head()

• ratings 评分表中包含了用户 id、电影 id、评分等级、时间戳等信息；

2).表连接

可以看出三张表之间依靠 user_id、movie_id
可进行连接；

data=pd.merge(pd.merge(users,ratings),movies)

于是获得了一个每条评分信息的数据；数据内容如下：
由此可进行以下分析：

1.按性别查看电影评分情况：

mean_ratings_gender =data.pivot_table(values='rating',index='title',columns='gender',aggfunc='mean')

2.获得评价人数最多的电影

#按电影名进行计数，获取每部电影的评价次数
ratings_by_movie_title=data.groupby('title')['user_id'].count().reset_index()
ratings_by_movie_title.columns=['title','count']
ratings_by_movie_title

#按计数次数进行排序，获得评分人数最多的10部电影
top_10_ratings=ratings_by_movie_title.sort_values(by='count',ascending=False).head(10)

3.获得评分数最高的电影

#获取每部电影的平均评分
mean_ratings=data.groupby('title')['rating'].mean().reset_index()
mean_ratings

#获取前20的高分电影
top_20_mean_ratings=mean_ratings.sort_values(by='rating',ascending=False).head(20)
top_20_mean_ratings

4.获得综合评价最高的电影

根据上面的表格可发现，有部分高分电影存在冷门情况，推测为较少人打分导致，故应结合评分人数进行综合评定；
先对平均评分表及评价次数表进行合并：

rating_rates=pd.merge(mean_ratings,ratings_by_movie_title)
rating_rates

将评价次数<1000的电影剔除，再进行评分降序排序：

rating_rates_1=rating_rates[rating_rates['count']>=1000
rating_rates_1.sort_values(by='rating',ascending=False)

至此我们就获得了一份较为靠谱的高分电影观影指南。
排名靠前的有《肖申克的救赎》《教父》《非常嫌疑犯》《辛德勒名单》《夺宝奇兵》等等。