1 为什么使用Pandas

1. 增强图表可读性
2. 便捷的数据处理能力
3. 读取文件方便
4. 封装了Matplotlib、Numpy的画图和计算

2 Pandas数据结构

1。Pandas中一共有三种数据结构，分别为：Series、DataFrame和MultiIndex（老版本中叫Panel ）。
2。其中Series是一维数据结构，DataFrame是二维的表格型数据结构，MultiIndex是三维的数据结构。

3 Pandas 常见操作详解

3.1 导入数据

import pandas as pd df = pd.read_csv(# 该参数为数据在电脑中的路径，可以不填写filepath_or_buffer='/Users/Haiwang/Desktop/sz000002.csv',# 该参数代表数据的分隔符，csv文件默认是逗号。其他常见的是'\t'sep=',',# 该参数代表跳过数据文件的的第1行不读入skiprows=1,# nrows，只读取前n行数据，若不指定，读入全部的数据nrows=15,# 将指定列的数据识别为日期格式。若不指定，时间数据将会以字符串形式读入。一开始先不用。# parse_dates=['交易日期'],# 将指定列设置为index。若不指定，index默认为0, 1, 2, 3, 4...# index_col=['交易日期'],# 读取指定的这几列数据，其他数据不读取。若不指定，读入全部列usecols=['交易日期', '股票代码', '股票名称', '收盘价', '涨跌幅', '成交量', '新浪概念', 'MACD_金叉死叉'],# 当某行数据有问题时，报错。设定为False时即不报错，直接跳过该行。当数据比较脏乱的时候用这个。error_bad_lines=False,# 将数据中的null识别为空值na_values='NULL',
)

3.2 查看数据常用操作

print(df.shape)  # 输出dataframe有多少行、多少列。
print(df.shape[0])  # 取行数量，相应的列数量就是df.shape[1]
print(df.columns) # 顺序输出每一列的名字，演示如何for语句遍历。
print(df.index) # 顺序输出每一行的名字，可以for语句遍历。
print(df.dtypes) # 数据每一列的类型不一样，比如数字、字符串、日期等。该方法输出每一列变量类型
print(df.head(3))  # 看前3行的数据，默认是5。与自然语言很接近
print(df.tail(3))  # 看最后3行的数据，默认是5。
print(df.sample(n=3))  # 随机抽取3行，想要去固定比例的话，可以用frac参数
print(df.describe())  # 非常方便的函数，对每一列数据有直观感受；只会对数字类型的列有效

3.3 读取指定的数据

3.3.1 如何选取指定的行、列

print(df['股票代码'])  # 根据列名称来选取，读取的数据是Series类型
print(df[['股票代码', '收盘价']]) # 同时选取多列，需要两个括号，读取的数据是DataFrame类型
print(df[[0, 1, 2]])  # 也可以通过列的position来选取

3.3.2 loc操作：通过label（columns和index的名字）来读取数据

print(df.loc['12/12/2016']) # 选取指定的某一行，读取的数据是Series类型
print(df.loc['13/12/2016': '06/12/2016'])  # 选取在此范围内的多行，和在list中slice操作类似，读取的数据是DataFrame类型
print(df.loc[:, '股票代码':'收盘价']) # 选取在此范围内的多列，读取的数据是DataFrame类型
print(df.loc['13/12/2016': '06/12/2016', '股票代码':'收盘价'])  # 读取指定的多行、多列。逗号之前是行的范围，逗号之后是列的范围。读取的数据是DataFrame类型
print(df.loc[:, :])  # 读取所有行、所有列，读取的数据是DataFrame类型
print(df.at['12/12/2016', '股票代码'])  # 使用at读取指定的某个元素。loc也行，但是at更高效。

3.3.3 iloc操作：通过position来读取数据

print(df.iloc[0]) # 以index选取某一行，读取的数据是Series类型
print(df.iloc[1:3]) # 选取在此范围内的多行，读取的数据是DataFrame类型
print(df.iloc[:, 1:3])  # 选取在此范围内的多列，读取的数据是DataFrame类型
print(df.iloc[1:3, 1:3])  # 读取指定的多行、多列，读取的数据是DataFrame类型
print(df.iloc[:, :])  # 读取所有行、所有列，读取的数据是DataFrame类型
print(df.iat[1, 1])  # 使用iat读取指定的某个元素。使用iloc也行，但是iat更高效。

3.3.4 筛选操作，根据指定的条件，筛选出相关拿数据

print(df['股票代码'] == 'sh000002') # 判断股票代码是否等于sz000002
print(df[df['股票代码'] == 'sz000002'])  # 将判断为True的输出：选取股票代码等于sz000002的行
print(df[df['股票代码'].isin(['sz000002', 'sz000003 ', 'sz000004'])])  # 选取股票代码等于XXX的行
print(df[df['收盘价'] >= 24.0])  # 选取收盘价大于等于24的行
print(df[(df.index >= '03/12/2016') & (df.index <= '06/12/2016')])  # 两个条件，或者的话就是|

4 对数据进行相关操作的函数

4.1 列操作：行列加减乘除、新增列

print(df['股票名称'] + '_地产')  # 字符串列可以直接加上字符串，对整列进行操作
print(df['收盘价'] * 100)  # 数字列直接加上或者乘以数字，对整列进行操作。
print(df['收盘价'] * df['成交量'])  # 两列之间可以直接操作。收盘价*成交量计算出的是什么？
df['股票名称+行业'] = df['股票名称'] + '_地产'

4.2 统计函数

print(df['收盘价'].mean())  # 求一整列的均值，返回一个数。会自动排除空值。
print(df[['收盘价', '成交量']].mean())  # 求两列的均值，返回两个数，Series
print(df[['收盘价', '成交量']])
print(df[['收盘价', '成交量']].mean(axis=1))  # 求两列的均值，返回DataFrame。axis=0或者1要搞清楚。#axis=1，代表对整几列进行操作。axis=0（默认）代表对几行进行操作。实际中弄混很正常，到时候试一下就知道了。
print(df['收盘价'].max())  # 最大值
print(df['收盘价'].min())  # 最小值
print(df['收盘价'].std())  # 标准差
print(df['收盘价'].count())  # 非空的数据的数量
print(df['收盘价'].median())  # 中位数
print(df['收盘价'].quantile(0.25))  # 25%分位数

4.3 shift类函数、删除列的方式

df['昨天收盘价'] = df['收盘价'].shift(-1) 
print(df[['收盘价', '昨天收盘价']])
del df['昨天收盘价']  # 删除某一列的方法df['涨跌'] = df['收盘价'].diff(-1)  # 求本行数据和上一行数据相减得到的值
print(df[['收盘价', '涨跌']])
df.drop(['涨跌'], axis=1, inplace=True)  # 删除某一列的另外一种方式，inplace参数指是否替代原来的df
print(df)
df['涨跌幅_计算'] = df['收盘价'].pct_change(-1)  # 类似于diff，但是求的是两个数直接的比例，相当于求涨跌幅

4.4 cum(cumulative)类函数

df['成交量_cum'] = df['成交量'].cumsum()  # 该列的累加值
print(df[['成交量', '成交量_cum']])
print((df['涨跌幅'] + 1.0).cumprod())  # 该列的累乘值，此处计算的就是资金曲线，假设初始1元钱。

4.5 其他列函数

df['收盘价_排名'] = df['收盘价'].rank(ascending=True, pct=False)  # 输出排名。ascending参数代表是顺序还是逆序。pct参数代表输出的是排名还是排名比例
print(df[['收盘价', '收盘价_排名']])
del df['收盘价_排名']
print(df['股票代码'].value_counts())  # 计数。统计该列中每个元素出现的次数。返回的数据是Series

4.6 排序函数

df.reset_index(inplace=True)
print(df.sort_values(by=['交易日期'], ascending=1))  # by参数指定按照什么进行排序，acsending参数指定是顺序还是逆序，1顺序，0逆序
print(df.sort_values(by=['股票名称', '交易日期'], ascending=[1, 1]))  # 按照多列进行排序

4.7 两个df上下合并操作，append操作

df.reset_index(inplace=True)
df1 = df.iloc[0:10][['交易日期', '股票代码', '收盘价', '涨跌幅']]
print(df1)
df2 = df.iloc[5:15][['交易日期', '股票名称', '收盘价', '涨跌幅']]
print(df2)
print(df1.append(df2))  # append操作，将df1和df2上下拼接起来。注意观察拼接之后的index
df3 = df1.append(df2, ignore_index=True)  # ignore_index参数，用户重新确定index
print(df3)

4.8 对数据进行去重

df3.drop_duplicates(subset=['收盘价', '交易日期'],  # subset参数用来指定根据哪类类数据来判断是否重复。若不指定，则用全部列的数据来判断是否重复keep='first',  # 在去除重复值的时候，我们是保留上面一行还是下面一行？first保留上面一行，last保留下面一行，False就是一行都不保留inplace=True
)
print(df3)

4.9 其他常用重要函数

print(df.rename(columns={'MACD_金叉死叉': '金叉死叉', '涨跌幅': '涨幅'}))  # rename函数给变量修改名字。使用dict将要修改的名字传给columns参数
print(df.empty)  # 判断一个df是不是为空，此处输出不为空
print(pd.DataFrame().empty)  # pd.DataFrame()创建一个空的DataFrame，此处输出为空
print(df.T)  # 将数据转置，行变成列，很有用

4.10 rolling、expanding操作

print(df['收盘价'].mean())    #计算'收盘价'这一列的均值
df['收盘价_3天均值'] = df['收盘价'].rolling(5).mean()    #如何得到每一天的最近3天收盘价的均值呢？即如何计算常用的移动平均线？使用rolling函数
print(df[['收盘价', '收盘价_3天均值']])
print(df['收盘价'].rolling(3).max())    #rolling(n)即为取最近n行数据的意思，只计算这n行数据。后面可以接各类计算函数，例如max、min、std等
print(df['收盘价'].rolling(3).min())
print(df['收盘价'].rolling(3).std())
## 20.2 rolling可以计算每天的最近3天的均值，如果想计算每天的从一开始至今的均值，应该如何计算？  使用expanding操作
df['收盘价_至今均值'] = df['收盘价'].expanding().mean()
print(df[['收盘价', '收盘价_至今均值']])
print(df['收盘价'].expanding().max())
print(df['收盘价'].expanding().min())
print(df['收盘价'].expanding().std())

4.11 高级处理-数据表的合并

如果你的数据由多张表组成，那么有时候需要将不同的内容合并在一起分析

1。pd.concat实现数据合并：

        pd.concat([data, dummies], axis=1)  # 按照行索引（横向增加）进行数据合并（按照行或列（纵向增加）进行合并,axis=0为列索引，axis=1为行索引）

2。pd.merge：

        # pd.merge(left, right, how='inner', on=None)可以指定按照两组数据的共同键值对合并或者左右各自left: DataFrameright: 另一个DataFrameon: 指定的共同键，连接的键的依据是哪几个how:按照什么方式连接：Merge method	SQL Join Name	    Descriptionleft	        LEFT OUTER JOIN	    Use keys from left frame onlyright	        RIGHT OUTER JOIN	Use keys from right frame onlyouter	        FULL OUTER JOIN	    Use union of keys from both framesinner	        INNER JOIN	        Use intersection of keys from both frames#  匹配不上的，就不加入，或者有的是填充进NaNleft = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],'key2': ['K0', 'K1', 'K0', 'K1'],'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],'key2': ['K0', 'K0', 'K0', 'K0'],'C': ['C0', 'C1', 'C2', 'C3'],'D': ['D0', 'D1', 'D2', 'D3']})             result = pd.merge(left, right, on=['key1', 'key2'])   # 默认内连接result = pd.merge(left, right, how='left', on=['key1', 'key2'])     # 左连接result = pd.merge(left, right, how='right', on=['key1', 'key2'])    # 右连接result = pd.merge(left, right, how='outer', on=['key1', 'key2'])    外链接

4.12 高级处理-交叉表与透视表

1。交叉表（cross-tabulation, 简称crosstab）与透视表（pivot table）什么作用：

    1.1 交叉表：交叉表用于计算一列数据对于另外一列数据的分组个数(用于统计分组频率的特殊透视表)* 交叉表：计算一列数据对于另外一列数据的分组个数。pd.crosstab(value1, value2)1.2 透视表：透视表是将原有的DataFrame的列分别作为行索引和列索引，然后对指定的列应用聚集函数。* 透视表：指定某一列对另一列的关系。data.pivot_table(）DataFrame.pivot_table([], index=[])

2。 案例分析： 寻找星期几跟股票涨跌的关系

    2.1 数据准备：date = pd.to_datetime(data.index).weekday   # 先把对应的日期进行转换 找到星期几data['week'] = datedata['posi_neg'] = np.where(data['p_change'] > 0, 1, 0)     # p_change为正则记为1，小于0则记为0count = pd.crosstab(data['week'], data['posi_neg'])  # 通过交叉表找寻两列数据的关系2.2 查看效果：sum = count.sum(axis=1).astype(np.float32)  # 按行统计，算数求和pro = count.div(sum, axis=0)    # 进行相除操作，得出比例pro.plot(kind='bar', stacked=True) # stacked参数：是否进行堆积plt.show()
3。寻找星期几跟股票涨跌的关系 -- 使用pivot_table(透视表)实现：更简单data.pivot_table(['posi_neg'], index='week')

4.13 高级处理-分组与聚合

1。分组与聚合通常是分析数据的一种方式，通常与一些统计函数一起使用，查看数据的分组情况

2。分组API：DataFrame.groupby(key, as_index=False) # key: 分组的列数据，可以多个

    2.1 案例:不同颜色的不同笔的价格数据：col =pd.DataFrame({'color': ['white','red','green','red','green'], 'object': ['pen','pencil','pencil','ashtray','pen'],'price1':[5.56,4.20,1.30,0.56,2.75],'price2':[4.75,4.12,1.60,0.75,3.15]})# 进行分组，对颜色分组，price进行聚合：# 分组，求平均值col.groupby(['color'])['price1'].mean()     # 基于 color 来对 price1 进行分组聚合# col['price1'].groupby(col['color']).mean()# 分组，数据的结构不变col.groupby(['color'], as_index=False)['price1'].mean()

3。星巴克零售店铺数据：

    starbucks = pd.read_csv("./data/starbucks/directory.csv")   # 导入星巴克店的数据count = starbucks.groupby(['Country']).count()      # 按照国家分组，求出每个国家的星巴克零售店数量count['Brand'].plot(kind='bar', figsize=(20, 8))    # 画图显示结果plt.show()starbucks.groupby(['Country', 'State/Province']).count()    # 加入省市一起进行分组。设置多个索引，set_index()

5 缺失值处理

1。如何处理 NaN

    1.1 判断数据中是否包含NaN：pd.isnull(df)pd.notnull(df)1.2 存在缺失值nan:1.2.1 删除存在缺失值的:dropna(axis='rows')1.2.2 替换缺失值:fillna(value, inplace=True)1.3 如果缺失值没有使用NaN标记，比如使用"？"  先替换‘?’为np.nan，然后继续处理

2。电影数据的缺失值处理：

            movie = pd.read_csv("./data/IMDB-Movie-Data.csv")       # 读取电影数据

2.1 判断缺失值是否存在

            # pd.notnull(movie)   # 判断缺失值是否存在np.all(pd.notnull(movie)) # 里面如果有一个缺失值，就会返回　False，说明有缺失值np.any(pd.isnull(movie)) # 里面如果有一个缺失值，就会返回　 True，说明有缺失值

2.2 处理nan缺失值

            # 存在缺失值nan,并且是np.nan2.2.1 删除movie.dropna()  # 不修改原数据，直接删除掉NAN对应的行数据# data = movie.dropna()   # 可以定义新的变量接受或者用原来的变量名2.2.2 替换某一列的缺失值：# 替换存在缺失值的样本的两列：替换填充平均值，中位数# movie['Revenue (Millions)'].fillna(movie['Revenue (Millions)'].mean(), inplace=True)2.2.3 替换所有缺失值：for i in movie.columns:     # i 代表 列if np.all(pd.notnull(movie[i])) == False:   # 说明里面有缺失值print(i)    # 打印一下 有缺失值的列名movie[i].fillna(movie[i].mean(), inplace=True) # 用第i列的数据的平均数作为填充值，填充到该列为NaN的位置去。

2.3 处理不是 NaN，但是有默认标记的缺失值：

            wis = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data")

2.3.1 全局取消证书验证

            import sslssl._create_default_https_context = ssl._create_unverified_context

2.3.2 先替换‘?’为np.nan，把一些其它值标记的缺失值，替换成np.nan

            wis = wis.replace(to_replace='?', value=np.nan)     wis = wis.dropna()  # 在进行缺失值的处理

# 找出缺失值
print(df.notnull())  # 判断是否为空值，反向函数为isnull()
print(df[df['MACD_金叉死叉'].notnull()])  # 将'MACD_金叉死叉'列为空的行输出# 删除缺失值
print(df.dropna(how='any'))  # 将带有空值的行删除。how='any'意味着，该行中只要有一个空值，就会删除，可以改成all。
print(df.dropna(subset=['MACD_金叉死叉', '涨跌幅'], how='all'))  # subset参数指定在特定的列中判断空值。#all代表全部为空，才会删除该行；any只要一个为空，就删除该行。## 13.2 补全缺失值
print(df.fillna(value='没有金叉死叉'))  # 直接将缺失值赋值为固定的值
df['MACD_金叉死叉'].fillna(value=df['收盘价'], inplace=True)  # 直接将缺失值赋值其他列的数据
print(df.fillna(method='ffill'))  # 向上寻找最近的一个非空值，以该值来填充缺失的位置，全称forward fill，非常有用
print(df.fillna(method='bfill'))  # 向下寻找最近的一个非空值，以该值来填充确实的位置，全称backward fill

6 字符串处理

print(df['股票代码'])
print('sz000002'[:2])
print(df['股票代码'].str[:2])
print(df['股票代码'].str.upper())  # 加上str之后可以使用常见的字符串函数对整列进行操作
print(df['股票代码'].str.lower())
print(df['股票代码'].str.len())  # 计算字符串的长度,length
df['股票代码'].str.strip()  # strip操作，把字符串两边的空格去掉
print(df['股票代码'].str.contains('sh'))  # 判断字符串中是否包含某些特定字符
print(df['股票代码'].str.replace('sz', 'sh'))  # 进行替换，将sz替换成sh
## 18.2 split操作
print(df['新浪概念'].str.split('；'))  # 对字符串进行分割
print(df['新浪概念'].str.split('；').str[:2])  # 分割后取第一个位置
print(df['新浪概念'].str.split('；', expand=True))  # 分割后并且将数据分列

7 时间戳处理

df['交易日期'] = pd.to_datetime(df['交易日期'])  # 将交易日期由字符串改为时间变量
print(df['交易日期'])
print(df.iloc[0]['交易日期'])
print(df.dtypes)
print(pd.to_datetime('1999年01月01日')) # pd.to_datetime函数：将字符串转变为时间变量
print(df.at[0, '交易日期'])
print(df['交易日期'].dt.year)  # 输出这个日期的年份。相应的month是月份，day是天数，还有hour, minute, second
print(df['交易日期'].dt.week)  # 这一天是一年当中的第几周
print(df['交易日期'].dt.dayofyear)  # 这一天是一年当中的第几天
print(df['交易日期'].dt.dayofweek) # 这一天是这一周当中的第几天，0代表星期一
print(df['交易日期'].dt.weekday)  # 和上面函数相同，更加常用
print(df['交易日期'].dt.weekday_name)  # 和上面函数相同，返回的是星期几的英文，用于报表的制作。
print(df['交易日期'].dt.days_in_month)  # 这一天是这一月当中的第几天
print(df['交易日期'].dt.is_month_end)  # 这一天是否是该月的开头，是否存在is_month_end？
print(df['交易日期'] + pd.Timedelta(days=1))  # 增加一天，Timedelta用于表示时间差数据
print((df['交易日期'] + pd.Timedelta(days=1)) - df['交易日期'])  # 增加一天然后再减去今天的日期

7.2 使用python中的datetime获取当前的年份、月份、天数、小时数、分钟数、秒数

import datetimenow = datetime.datetime.now()print('now is ', now)
print('the year of now is', now.year)
print('the month of now is ', now.month)
print('the day of now is ', now.day)
print('the hour of now is ', now.hour)
print('the minute of now is ', now.minute)
print('the second of now is ', now.second)

7.3 从字符串创建datetime对象：

datetime.strptime(day, format="%Y-%m-%d")

！！！pandas函数的to_datetime生成的对象并不是datetime.datetime，而是Timestamp，它是从Python标准库的datetime类继承过来的，表示时间轴上的一个时刻，注意区别。

8 输出数据

1。CSV文件：1.1 读取CSV文件 pandas.read_csv(filepath_or_buffer, sep =',', usecols )         # usecols:指定读取的列名，列表形式data = pd.read_csv("./data/stock_day.csv", usecols=['open', 'close'])   # 读取文件,并且指定只获取'open', 'close'指标1.2 保存CSV文件 DataFrame.to_csv(path_or_buf=None, sep=', ’, columns=None, header=True, index=True, mode='w', encoding=None)# header :boolean or list of string, default True,是否写进列索引值# index:是否写进行索引# mode:'w'：重写, 'a' 追加  data[:10].to_csv("./data/test.csv", columns=['open'])   # 选取10行数据保存,便于观察数据data[:10].to_csv("./data/test.csv", columns=['open'], index=False)  # index:存储时，不写入索引

print(df)
df.to_csv('output.csv', encoding='gbk', index=False)

9 电影案例分析

1。需求：现在我们有一组从2006年到2016年1000部最流行的电影数据

        数据来源：https://www.kaggle.com/damianpanek/sunday-eda/data问题1：我们想知道这些电影数据中评分的平均分，导演的人数等信息，我们应该怎么获取？问题2：对于这一组电影数据，如果我们想rating，runtime的分布情况，应该如何呈现数据？问题3：对于这一组电影数据，如果我们希望统计电影分类(genre)的情况，应该如何处理数据？

2。实现：

2.1 我们想知道这些电影数据中评分的平均分，导演的人数等信息，我们应该怎么获取？

    %matplotlib inlineimport pandas  as pd import numpy as npfrom matplotlib import pyplot as pltdf = pd.read_csv("./data/IMDB-Movie-Data.csv")    # 读取文件df["Rating"].mean()     # 得出评分的平均分np.unique(df["Director"]).shape[0]    # 得出导演人数信息，去重复

2.2 对于这一组电影数据，如果我们想rating，runtime的分布情况，应该如何呈现数据？

    df["Rating"].plot(kind='hist',figsize=(20,8))    # 直接呈现，以直方图的形式# Rating进行分布展示# 进行绘制直方图plt.figure(figsize=(20,8),dpi=80)    plt.hist(df["Rating"].values,bins=20)plt.show()     # 修改刻度的间隔# 求出最大最小值max_ = df["Rating"].max()min_ = df["Rating"].min()# 生成刻度列表t1 = np.linspace(min_,max_,num=21)    # 分成20组，需要21个刻度值plt.xticks(t1)  # 修改刻度plt.grid()  # 添加网格# Runtime (Minutes)进行分布展示plt.figure(figsize=(20,8),dpi=80)plt.hist(df["Runtime (Minutes)"].values,bins=20)plt.show()# 求出最大最小值max_ = df["Runtime (Minutes)"].max()min_ = df["Runtime (Minutes)"].min()# # 生成刻度列表t1 = np.linspace(min_,max_,num=21)           # 修改刻度plt.xticks(np.linspace(min_,max_,num=21))          # 添加网格plt.grid()plt.show() 

2.3 对于这一组电影数据，如果我们希望统计电影分类(genre)的情况，应该如何处理数据？

    # 1。创建一个全为0的dataframe，列索引置为电影的分类，temp_dftemp_list = [i.split(",") for i in df["Genre"]]    # 进行字符串分割 # 此时得到的分类列表是类似于：[['A','B','D'],['B'],['C','D']]genre_list = np.unique([i for j in temp_list for i in j])     # 获取电影的分类zeros = np.zeros([df.shape[0], genre_list.shape[0]])temp_df = pd.DataFrame(zeros, columns=genre_list)     # 增加新的列# 2。遍历每一部电影，temp_df中把分类出现的列的值置为1for i in range(1000):#temp_list[i] ['Action','Adventure','Animation']temp_df.ix[i,temp_list[i]]=1print(temp_df.sum().sort_values())# 3。求和,绘图genre = temp_df.sum().sort_values(ascending=False)genre.plot(kind="bar",figsize=(20,8),fontsize=20,colormap="cool")

10 Series与DataFrame 比较与知识补充

10.1 导包，创数据

import numpy as np
import pandas as pd
from pandas import Sereis, DataFrameser = Series(np.arange(3.))
data = DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list('wxyz'))

10.2 DataFrame选择列

data['w']  #选择表格中的'w'列，使用类字典属性,返回的是Series类型
data.w    #选择表格中的'w'列，使用点属性,返回的是Series类型
data[['w']]  #选择表格中的'w'列，返回的是DataFrame属性
data[['w','z']]  #选择表格中的'w'、'z'列
data.icol(0)   #取data的第一列

10.3 DataFrame选择行

data[0:2]  #返回第1行到第2行的所有行，前闭后开，包括前不包括后
data[1:2]  #返回第2行，从0计，返回的是单行，通过有前后值的索引形式，#如果采用data[1]则报错
data.ix[1:2] #返回第2行的第三种方法，返回的是DataFrame，跟data[1:2]同
data['a':'b']  #利用index值进行切片，返回的是**前闭后闭**的DataFrame, #即末端是包含的 
data.irow(0)   #取data的第一行
data.iloc[-1]   #选取DataFrame最后一行，返回的是Series
data.iloc[-1:]   #选取DataFrame最后一行，返回的是DataFramedata.head()  #返回data的前几行数据，默认为前五行，需要前十行则dta.head(10)
data.tail()  #返回data的后几行数据，默认为后五行，需要后十行则data.tail(10)

10.4 Series选择数据

ser.iget_value(0)  #选取ser序列中的第一个
ser.iget_value(-1) #选取ser序列中的最后一个，这种轴索引包含索引器的series不能采用ser[-1]去获取最后一个，这回引起歧义。data.loc['a',['w','x']]   #返回‘a’行'w'、'x'列，这种用于选取行索引列索引已知
data.iat[1,1]   #选取第二行第二列，用于已知行、列位置的选取。